cowork-os 0.3.21

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

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProvider = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+/**
+ * Google AI Studio (Gemini) provider implementation
+ */
+class GeminiProvider {
+    constructor(config) {
+        this.type = 'gemini';
+        // Track tool names and thought signatures for result mapping
+        this.toolIdToName = new Map();
+        this.toolIdToThoughtSignature = new Map();
+        const apiKey = config.geminiApiKey;
+        if (!apiKey) {
+            throw new Error('Gemini API key is required. Configure it in Settings or get one from https://aistudio.google.com/apikey');
+        }
+        this.client = new generative_ai_1.GoogleGenerativeAI(apiKey);
+        this.defaultModel = config.model || 'gemini-2.0-flash';
+    }
+    async createMessage(request) {
+        const model = this.client.getGenerativeModel({
+            model: request.model || this.defaultModel,
+            systemInstruction: request.system,
+        });
+        const contents = this.convertMessages(request.messages);
+        const tools = request.tools ? this.convertTools(request.tools) : undefined;
+        try {
+            console.log(`[Gemini] Calling API with model: ${request.model || this.defaultModel}`);
+            const result = await model.generateContent({
+                contents,
+                generationConfig: {
+                    maxOutputTokens: request.maxTokens,
+                },
+                ...(tools && {
+                    tools,
+                    toolConfig: {
+                        functionCallingConfig: {
+                            mode: generative_ai_1.FunctionCallingMode.AUTO,
+                        },
+                    },
+                }),
+            }, 
+            // Pass abort signal to allow cancellation
+            request.signal ? { signal: request.signal } : undefined);
+            const response = result.response;
+            return this.convertResponse(response);
+        }
+        catch (error) {
+            // Handle abort errors gracefully
+            if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+                console.log(`[Gemini] Request aborted`);
+                throw new Error('Request cancelled');
+            }
+            console.error(`[Gemini] API error:`, {
+                message: error.message,
+                status: error.status,
+                statusText: error.statusText,
+            });
+            throw error;
+        }
+    }
+    async testConnection() {
+        try {
+            const model = this.client.getGenerativeModel({ model: this.defaultModel });
+            await model.generateContent({
+                contents: [{ role: 'user', parts: [{ text: 'Hi' }] }],
+                generationConfig: { maxOutputTokens: 10 },
+            });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to Gemini API',
+            };
+        }
+    }
+    convertMessages(messages) {
+        return messages.map((msg) => {
+            const parts = [];
+            if (typeof msg.content === 'string') {
+                parts.push({ text: msg.content });
+            }
+            else {
+                // Handle array content (tool results or mixed content)
+                for (const item of msg.content) {
+                    if (item.type === 'tool_result') {
+                        // Gemini uses functionResponse for tool results
+                        parts.push({
+                            functionResponse: {
+                                name: this.getToolNameFromId(item.tool_use_id),
+                                response: {
+                                    result: item.content,
+                                    is_error: item.is_error || false,
+                                },
+                            },
+                        });
+                    }
+                    else if (item.type === 'tool_use') {
+                        // Gemini uses functionCall for tool invocations
+                        const thoughtSignature = this.getThoughtSignatureFromId(item.id);
+                        const functionCallPart = {
+                            functionCall: {
+                                name: item.name,
+                                args: item.input,
+                            },
+                        };
+                        // Include thought signature if present (required for Gemini 3 models)
+                        if (thoughtSignature) {
+                            functionCallPart.thoughtSignature = thoughtSignature;
+                        }
+                        parts.push(functionCallPart);
+                    }
+                    else if (item.type === 'text') {
+                        parts.push({ text: item.text });
+                    }
+                }
+            }
+            return {
+                role: msg.role === 'assistant' ? 'model' : 'user',
+                parts,
+            };
+        });
+    }
+    getToolNameFromId(toolUseId) {
+        return this.toolIdToName.get(toolUseId) || toolUseId;
+    }
+    getThoughtSignatureFromId(toolUseId) {
+        return this.toolIdToThoughtSignature.get(toolUseId);
+    }
+    /**
+     * Recursively sanitize schema for Gemini API compatibility.
+     * Gemini requires all nested objects/arrays to have explicit 'type' fields.
+     */
+    sanitizeSchemaForGemini(schema) {
+        if (!schema || typeof schema !== 'object') {
+            return schema;
+        }
+        const result = { ...schema };
+        // Ensure type field exists
+        if (!result.type) {
+            if (result.properties) {
+                result.type = generative_ai_1.SchemaType.OBJECT;
+            }
+            else if (result.items) {
+                result.type = generative_ai_1.SchemaType.ARRAY;
+            }
+            else if (typeof result.enum !== 'undefined') {
+                result.type = generative_ai_1.SchemaType.STRING;
+            }
+        }
+        // Convert string type names to SchemaType enum values
+        if (typeof result.type === 'string') {
+            const typeMap = {
+                'string': generative_ai_1.SchemaType.STRING,
+                'number': generative_ai_1.SchemaType.NUMBER,
+                'integer': generative_ai_1.SchemaType.INTEGER,
+                'boolean': generative_ai_1.SchemaType.BOOLEAN,
+                'array': generative_ai_1.SchemaType.ARRAY,
+                'object': generative_ai_1.SchemaType.OBJECT,
+            };
+            result.type = typeMap[result.type.toLowerCase()] || result.type;
+        }
+        // Recursively process properties
+        if (result.properties) {
+            const sanitizedProperties = {};
+            for (const [key, value] of Object.entries(result.properties)) {
+                sanitizedProperties[key] = this.sanitizeSchemaForGemini(value);
+            }
+            result.properties = sanitizedProperties;
+        }
+        // Handle array types - ensure items exists and has a type
+        if (result.type === generative_ai_1.SchemaType.ARRAY || result.type === 'array') {
+            if (!result.items) {
+                // Add default items if missing for array type
+                result.items = { type: generative_ai_1.SchemaType.STRING };
+            }
+            else {
+                result.items = this.sanitizeSchemaForGemini(result.items);
+                // Ensure items has a type
+                if (!result.items.type) {
+                    result.items.type = generative_ai_1.SchemaType.STRING;
+                }
+            }
+        }
+        return result;
+    }
+    convertTools(tools) {
+        const functionDeclarations = tools.map((tool) => {
+            // Sanitize the entire parameters schema for Gemini compatibility
+            const sanitizedProperties = {};
+            if (tool.input_schema.properties) {
+                for (const [key, value] of Object.entries(tool.input_schema.properties)) {
+                    sanitizedProperties[key] = this.sanitizeSchemaForGemini(value);
+                }
+            }
+            return {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                    type: generative_ai_1.SchemaType.OBJECT,
+                    properties: sanitizedProperties,
+                    required: tool.input_schema.required || [],
+                },
+            };
+        });
+        return [{ functionDeclarations }];
+    }
+    convertResponse(response) {
+        const content = [];
+        const candidate = response.candidates?.[0];
+        if (!candidate) {
+            return {
+                content: [{ type: 'text', text: '' }],
+                stopReason: 'end_turn',
+            };
+        }
+        for (const part of candidate.content?.parts || []) {
+            if (part.text) {
+                content.push({
+                    type: 'text',
+                    text: part.text,
+                });
+            }
+            else if (part.functionCall) {
+                const toolUseId = `gemini_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                this.toolIdToName.set(toolUseId, part.functionCall.name);
+                // Capture thought signature if present (required for Gemini 3 models)
+                if (part.thoughtSignature) {
+                    this.toolIdToThoughtSignature.set(toolUseId, part.thoughtSignature);
+                }
+                content.push({
+                    type: 'tool_use',
+                    id: toolUseId,
+                    name: part.functionCall.name,
+                    input: part.functionCall.args || {},
+                });
+            }
+        }
+        // If no content was parsed, return empty text
+        if (content.length === 0) {
+            content.push({ type: 'text', text: '' });
+        }
+        return {
+            content,
+            stopReason: this.mapStopReason(candidate.finishReason),
+            usage: response.usageMetadata
+                ? {
+                    inputTokens: response.usageMetadata.promptTokenCount || 0,
+                    outputTokens: response.usageMetadata.candidatesTokenCount || 0,
+                }
+                : undefined,
+        };
+    }
+    mapStopReason(finishReason) {
+        switch (finishReason) {
+            case 'STOP':
+                return 'end_turn';
+            case 'MAX_TOKENS':
+                return 'max_tokens';
+            case 'SAFETY':
+            case 'RECITATION':
+            case 'OTHER':
+                return 'stop_sequence';
+            default:
+                // Check if we have function calls (tool use)
+                return 'end_turn';
+        }
+    }
+    /**
+     * Fetch available models from Gemini API
+     */
+    async getAvailableModels() {
+        try {
+            // Use the REST API to list models since the SDK doesn't expose listModels well
+            const apiKey = this.client.apiKey;
+            const maskedKey = apiKey ? `${apiKey.substring(0, 8)}...${apiKey.substring(apiKey.length - 4)}` : 'undefined';
+            console.log(`[Gemini] Fetching models with API key: ${maskedKey}`);
+            const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
+            if (!response.ok) {
+                const errorBody = await response.text();
+                console.error(`[Gemini] Failed to fetch models - Status: ${response.status} ${response.statusText}`);
+                console.error(`[Gemini] Error response body:`, errorBody);
+                return this.getDefaultModels();
+            }
+            const data = await response.json();
+            // Patterns to exclude non-text models
+            const excludePatterns = [
+                /imagen/i, // Image generation models
+                /embedding/i, // Embedding models
+                /aqa/i, // Attributed question answering
+                /vision/i, // Vision-only models
+                /audio/i, // Audio models
+                /speech/i, // Speech models
+                /tts/i, // Text-to-speech models
+                /robot/i, // Robotics models
+                /learnlm/i, // Learning models
+                /thinking/i, // Experimental thinking models
+                /native-audio/i, // Native audio models
+                /live/i, // Live/streaming models (not for text generation)
+                /nano/i, // Nano models (on-device/specialized)
+                /banana/i, // Image generation models (nano banana)
+                /veo/i, // Video generation models
+                /diffusion/i, // Diffusion models (image generation)
+            ];
+            const isTextModel = (modelName) => {
+                const name = modelName.toLowerCase();
+                // Must be a gemini model
+                if (!name.includes('gemini'))
+                    return false;
+                // Exclude non-text models
+                for (const pattern of excludePatterns) {
+                    if (pattern.test(name))
+                        return false;
+                }
+                // Must be a pro, flash, ultra, or nano variant (text models)
+                return name.includes('pro') || name.includes('flash') || name.includes('ultra');
+            };
+            const models = (data.models || [])
+                .filter((model) => model.supportedGenerationMethods?.includes('generateContent') &&
+                isTextModel(model.name || ''))
+                .map((model) => ({
+                name: model.name?.replace('models/', '') || '',
+                displayName: model.displayName || model.name?.replace('models/', '') || '',
+                description: model.description || '',
+            }))
+                .filter((model) => model.name);
+            // Sort models: newer versions first, pro before flash
+            // Dynamically extract version numbers (e.g., "3.0", "2.5", "2.0", "1.5")
+            const sortedModels = models.sort((a, b) => {
+                const extractVersion = (name) => {
+                    // Match patterns like "gemini-3.0", "gemini-2.5", "gemini-1.5-pro"
+                    const versionMatch = name.match(/gemini-?(\d+\.?\d*)/i);
+                    if (versionMatch) {
+                        return parseFloat(versionMatch[1]);
+                    }
+                    return 0;
+                };
+                const getTypeScore = (name) => {
+                    if (name.includes('pro'))
+                        return 0.03;
+                    if (name.includes('flash-lite') || name.includes('lite'))
+                        return 0.01;
+                    if (name.includes('flash'))
+                        return 0.02;
+                    return 0;
+                };
+                // Combine version (major sort) + type (minor sort)
+                const scoreA = extractVersion(a.name) + getTypeScore(a.name);
+                const scoreB = extractVersion(b.name) + getTypeScore(b.name);
+                return scoreB - scoreA;
+            });
+            return sortedModels.length > 0 ? sortedModels : this.getDefaultModels();
+        }
+        catch (error) {
+            console.error('Failed to fetch Gemini models:', error);
+            return this.getDefaultModels();
+        }
+    }
+    /**
+     * Get default models when API call fails
+     */
+    getDefaultModels() {
+        return [
+            { name: 'gemini-2.5-pro-preview-05-06', displayName: 'Gemini 2.5 Pro', description: 'Most capable model for complex tasks' },
+            { name: 'gemini-2.5-flash-preview-05-20', displayName: 'Gemini 2.5 Flash', description: 'Fast and efficient for most tasks' },
+            { name: 'gemini-2.0-flash', displayName: 'Gemini 2.0 Flash', description: 'Balanced speed and capability' },
+            { name: 'gemini-2.0-flash-lite', displayName: 'Gemini 2.0 Flash Lite', description: 'Fastest and most cost-effective' },
+            { name: 'gemini-1.5-pro', displayName: 'Gemini 1.5 Pro', description: 'Previous generation pro model' },
+            { name: 'gemini-1.5-flash', displayName: 'Gemini 1.5 Flash', description: 'Previous generation flash model' },
+        ];
+    }
+}
+exports.GeminiProvider = GeminiProvider;

package/dist/electron/electron/agent/llm/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMProviderFactory = exports.OpenAIOAuth = exports.OpenAIProvider = exports.OpenRouterProvider = exports.GeminiProvider = exports.OllamaProvider = exports.BedrockProvider = exports.AnthropicProvider = void 0;
+__exportStar(require("./types"), exports);
+var anthropic_provider_1 = require("./anthropic-provider");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_provider_1.AnthropicProvider; } });
+var bedrock_provider_1 = require("./bedrock-provider");
+Object.defineProperty(exports, "BedrockProvider", { enumerable: true, get: function () { return bedrock_provider_1.BedrockProvider; } });
+var ollama_provider_1 = require("./ollama-provider");
+Object.defineProperty(exports, "OllamaProvider", { enumerable: true, get: function () { return ollama_provider_1.OllamaProvider; } });
+var gemini_provider_1 = require("./gemini-provider");
+Object.defineProperty(exports, "GeminiProvider", { enumerable: true, get: function () { return gemini_provider_1.GeminiProvider; } });
+var openrouter_provider_1 = require("./openrouter-provider");
+Object.defineProperty(exports, "OpenRouterProvider", { enumerable: true, get: function () { return openrouter_provider_1.OpenRouterProvider; } });
+var openai_provider_1 = require("./openai-provider");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_provider_1.OpenAIProvider; } });
+var openai_oauth_1 = require("./openai-oauth");
+Object.defineProperty(exports, "OpenAIOAuth", { enumerable: true, get: function () { return openai_oauth_1.OpenAIOAuth; } });
+var provider_factory_1 = require("./provider-factory");
+Object.defineProperty(exports, "LLMProviderFactory", { enumerable: true, get: function () { return provider_factory_1.LLMProviderFactory; } });

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

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaProvider = void 0;
+/**
+ * Ollama API provider implementation
+ * Supports local and remote Ollama servers
+ * https://ollama.ai/
+ */
+class OllamaProvider {
+    constructor(config) {
+        this.type = 'ollama';
+        this.baseUrl = config.ollamaBaseUrl || 'http://localhost:11434';
+        this.apiKey = config.ollamaApiKey;
+        // Remove trailing slash if present
+        if (this.baseUrl.endsWith('/')) {
+            this.baseUrl = this.baseUrl.slice(0, -1);
+        }
+    }
+    async createMessage(request) {
+        const messages = this.convertMessages(request.messages, request.system);
+        const tools = request.tools ? this.convertTools(request.tools) : undefined;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        // Use AbortController for timeout (5 minutes for large models)
+        const timeoutController = new AbortController();
+        const timeoutId = setTimeout(() => timeoutController.abort(), 5 * 60 * 1000);
+        // Track if abort came from external signal (cancellation) vs timeout
+        let abortedByExternalSignal = false;
+        // If external signal provided, abort our controller when it fires
+        if (request.signal) {
+            request.signal.addEventListener('abort', () => {
+                abortedByExternalSignal = true;
+                timeoutController.abort();
+            });
+            // Check if already aborted
+            if (request.signal.aborted) {
+                abortedByExternalSignal = true;
+                timeoutController.abort();
+            }
+        }
+        try {
+            console.log(`[Ollama] Sending request to model: ${request.model}`);
+            const startTime = Date.now();
+            const response = await fetch(`${this.baseUrl}/api/chat`, {
+                method: 'POST',
+                headers,
+                signal: timeoutController.signal,
+                body: JSON.stringify({
+                    model: request.model,
+                    messages,
+                    stream: false,
+                    options: {
+                        num_predict: request.maxTokens,
+                    },
+                    ...(tools && tools.length > 0 && { tools }),
+                }),
+            });
+            clearTimeout(timeoutId);
+            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+            console.log(`[Ollama] Response received in ${elapsed}s`);
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`Ollama API error: ${response.status} - ${error}`);
+            }
+            const data = await response.json();
+            return this.convertResponse(data);
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            console.error(`[Ollama] API error:`, {
+                name: error.name,
+                message: error.message,
+                code: error.code,
+            });
+            if (error.name === 'AbortError') {
+                if (abortedByExternalSignal) {
+                    console.log(`[Ollama] Request aborted by user`);
+                    throw new Error('Request cancelled');
+                }
+                throw new Error('Ollama request timed out after 5 minutes. The model may be too slow or not responding.');
+            }
+            throw error;
+        }
+    }
+    async testConnection() {
+        try {
+            const headers = {};
+            if (this.apiKey) {
+                headers['Authorization'] = `Bearer ${this.apiKey}`;
+            }
+            // First check if Ollama is running
+            const response = await fetch(`${this.baseUrl}/api/tags`, { headers });
+            if (!response.ok) {
+                throw new Error(`Failed to connect to Ollama: ${response.status}`);
+            }
+            const data = await response.json();
+            if (!data.models || data.models.length === 0) {
+                return {
+                    success: false,
+                    error: 'No models available. Run "ollama pull <model>" to download a model.',
+                };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to Ollama server',
+            };
+        }
+    }
+    /**
+     * Fetch available models from Ollama server
+     */
+    async getAvailableModels() {
+        try {
+            const headers = {};
+            if (this.apiKey) {
+                headers['Authorization'] = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(`${this.baseUrl}/api/tags`, { headers });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch models: ${response.status}`);
+            }
+            const data = await response.json();
+            return (data.models || []).map(m => ({
+                name: m.name,
+                size: m.size,
+                modified: m.modified_at,
+            }));
+        }
+        catch (error) {
+            console.error('Failed to fetch Ollama models:', error);
+            return [];
+        }
+    }
+    convertMessages(messages, systemPrompt) {
+        const ollamaMessages = [];
+        // Add system message first
+        if (systemPrompt) {
+            ollamaMessages.push({
+                role: 'system',
+                content: systemPrompt,
+            });
+        }
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                ollamaMessages.push({
+                    role: msg.role === 'user' ? 'user' : 'assistant',
+                    content: msg.content,
+                });
+            }
+            else {
+                // Handle array content (tool results or mixed content)
+                const textParts = [];
+                const toolCalls = [];
+                for (const item of msg.content) {
+                    if (item.type === 'text') {
+                        textParts.push(item.text);
+                    }
+                    else if (item.type === 'tool_use') {
+                        toolCalls.push({
+                            function: {
+                                name: item.name,
+                                arguments: item.input,
+                            },
+                        });
+                    }
+                    else if (item.type === 'tool_result') {
+                        // Tool results in Ollama format
+                        ollamaMessages.push({
+                            role: 'tool',
+                            content: item.content,
+                        });
+                    }
+                }
+                if (textParts.length > 0 || toolCalls.length > 0) {
+                    ollamaMessages.push({
+                        role: msg.role === 'user' ? 'user' : 'assistant',
+                        content: textParts.join('\n') || '',
+                        ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+                    });
+                }
+            }
+        }
+        return ollamaMessages;
+    }
+    convertTools(tools) {
+        return tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema,
+            },
+        }));
+    }
+    convertResponse(response) {
+        const content = [];
+        const message = response.message;
+        // Handle missing message
+        if (!message) {
+            console.error('Ollama response missing message:', response);
+            return {
+                content: [{ type: 'text', text: 'Error: Ollama returned an empty response' }],
+                stopReason: 'end_turn',
+                usage: { inputTokens: 0, outputTokens: 0 },
+            };
+        }
+        // Handle text content
+        if (message.content) {
+            content.push({
+                type: 'text',
+                text: message.content,
+            });
+        }
+        // Handle tool calls
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            for (const toolCall of message.tool_calls) {
+                let args;
+                try {
+                    args = typeof toolCall.function.arguments === 'string'
+                        ? JSON.parse(toolCall.function.arguments)
+                        : toolCall.function.arguments || {};
+                }
+                catch (e) {
+                    console.error('Failed to parse tool arguments:', toolCall.function.arguments);
+                    args = {};
+                }
+                content.push({
+                    type: 'tool_use',
+                    id: `tool_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+                    name: toolCall.function.name,
+                    input: args,
+                });
+            }
+        }
+        // Determine stop reason
+        let stopReason = 'end_turn';
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            stopReason = 'tool_use';
+        }
+        else if (response.done_reason === 'length') {
+            stopReason = 'max_tokens';
+        }
+        else if (response.done_reason === 'stop') {
+            stopReason = 'stop_sequence';
+        }
+        return {
+            content,
+            stopReason,
+            usage: {
+                inputTokens: response.prompt_eval_count || 0,
+                outputTokens: response.eval_count || 0,
+            },
+        };
+    }
+}
+exports.OllamaProvider = OllamaProvider;