cowork-os 0.3.21 → 0.3.23

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

@@ -14,7 +14,7 @@ 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;
+exports.LLMProviderFactory = exports.OpenAIOAuth = exports.GitHubCopilotProvider = exports.AnthropicCompatibleProvider = exports.KimiProvider = exports.XAIProvider = exports.GroqProvider = 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; } });
@@ -28,6 +28,16 @@ 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 groq_provider_1 = require("./groq-provider");
+Object.defineProperty(exports, "GroqProvider", { enumerable: true, get: function () { return groq_provider_1.GroqProvider; } });
+var xai_provider_1 = require("./xai-provider");
+Object.defineProperty(exports, "XAIProvider", { enumerable: true, get: function () { return xai_provider_1.XAIProvider; } });
+var kimi_provider_1 = require("./kimi-provider");
+Object.defineProperty(exports, "KimiProvider", { enumerable: true, get: function () { return kimi_provider_1.KimiProvider; } });
+var anthropic_compatible_provider_1 = require("./anthropic-compatible-provider");
+Object.defineProperty(exports, "AnthropicCompatibleProvider", { enumerable: true, get: function () { return anthropic_compatible_provider_1.AnthropicCompatibleProvider; } });
+var github_copilot_provider_1 = require("./github-copilot-provider");
+Object.defineProperty(exports, "GitHubCopilotProvider", { enumerable: true, get: function () { return github_copilot_provider_1.GitHubCopilotProvider; } });
 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");

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KimiProvider = void 0;
+const openai_compatible_provider_1 = require("./openai-compatible-provider");
+const KIMI_BASE_URL = 'https://api.moonshot.ai/v1';
+const DEFAULT_KIMI_MODEL = 'kimi-k2.5';
+class KimiProvider {
+    constructor(config) {
+        this.type = 'kimi';
+        const apiKey = config.kimiApiKey;
+        if (!apiKey) {
+            throw new Error('Kimi API key is required. Configure it in Settings.');
+        }
+        const baseUrl = config.kimiBaseUrl || KIMI_BASE_URL;
+        this.client = new openai_compatible_provider_1.OpenAICompatibleProvider({
+            type: 'kimi',
+            providerName: 'Kimi',
+            apiKey,
+            baseUrl,
+            defaultModel: config.model || DEFAULT_KIMI_MODEL,
+        });
+    }
+    createMessage(request) {
+        return this.client.createMessage(request);
+    }
+    testConnection() {
+        return this.client.testConnection();
+    }
+    getAvailableModels() {
+        return this.client.getAvailableModels();
+    }
+}
+exports.KimiProvider = KimiProvider;

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleProvider = void 0;
+const openai_compatible_1 = require("./openai-compatible");
+class OpenAICompatibleProvider {
+    constructor(options) {
+        this.type = options.type;
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl;
+        this.defaultModel = options.defaultModel;
+        this.providerName = options.providerName;
+        this.extraHeaders = options.extraHeaders;
+    }
+    async createMessage(request) {
+        const messages = (0, openai_compatible_1.toOpenAICompatibleMessages)(request.messages, request.system);
+        const tools = request.tools ? (0, openai_compatible_1.toOpenAICompatibleTools)(request.tools) : undefined;
+        try {
+            const model = request.model || this.defaultModel;
+            console.log(`[${this.providerName}] Calling API with model: ${model}`);
+            const headers = {
+                'Content-Type': 'application/json',
+                ...(this.extraHeaders || {}),
+            };
+            if (this.apiKey) {
+                headers.Authorization = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    model,
+                    messages,
+                    max_tokens: request.maxTokens,
+                    ...(tools && { tools, tool_choice: 'auto' }),
+                }),
+                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 (0, openai_compatible_1.fromOpenAICompatibleResponse)(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 headers = {
+                'Content-Type': 'application/json',
+                ...(this.extraHeaders || {}),
+            };
+            if (this.apiKey) {
+                headers.Authorization = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    model: this.defaultModel,
+                    messages: [{ role: 'user', content: 'Hi' }],
+                    max_tokens: 10,
+                }),
+            });
+            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`,
+            };
+        }
+    }
+    async getAvailableModels() {
+        try {
+            const headers = {};
+            if (this.apiKey) {
+                headers.Authorization = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(`${this.baseUrl}/models`, {
+                headers,
+            });
+            if (!response.ok) {
+                return [];
+            }
+            const data = await response.json();
+            return (data.data || []).map((model) => ({
+                id: model.id,
+                name: model.id,
+            }));
+        }
+        catch (error) {
+            console.error(`[${this.providerName}] Failed to fetch models:`, error);
+            return [];
+        }
+    }
+}
+exports.OpenAICompatibleProvider = OpenAICompatibleProvider;

package/dist/electron/electron/agent/llm/openai-compatible.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOpenAICompatibleMessages = toOpenAICompatibleMessages;
+exports.toOpenAICompatibleTools = toOpenAICompatibleTools;
+exports.fromOpenAICompatibleResponse = fromOpenAICompatibleResponse;
+exports.mapStopReason = mapStopReason;
+function toOpenAICompatibleMessages(messages, system) {
+    const result = [];
+    if (system) {
+        result.push({ role: 'system', content: system });
+    }
+    for (const msg of messages) {
+        if (typeof msg.content === 'string') {
+            result.push({ role: msg.role, content: msg.content });
+            continue;
+        }
+        for (const item of msg.content) {
+            if (item.type === 'tool_result') {
+                result.push({
+                    role: 'tool',
+                    content: item.content,
+                    tool_call_id: item.tool_use_id,
+                });
+            }
+            else if (item.type === 'tool_use') {
+                result.push({
+                    role: 'assistant',
+                    content: null,
+                    tool_calls: [{
+                            id: item.id,
+                            type: 'function',
+                            function: {
+                                name: item.name,
+                                arguments: JSON.stringify(item.input),
+                            },
+                        }],
+                });
+            }
+            else if (item.type === 'text') {
+                result.push({ role: msg.role, content: item.text });
+            }
+        }
+    }
+    return result;
+}
+function toOpenAICompatibleTools(tools) {
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema,
+        },
+    }));
+}
+function fromOpenAICompatibleResponse(response) {
+    const content = [];
+    const choice = response.choices?.[0];
+    if (!choice) {
+        return {
+            content: [{ type: 'text', text: '' }],
+            stopReason: 'end_turn',
+        };
+    }
+    const message = choice.message;
+    if (message?.content) {
+        content.push({
+            type: 'text',
+            text: message.content,
+        });
+    }
+    if (message?.tool_calls) {
+        for (const toolCall of message.tool_calls) {
+            if (toolCall.type === 'function') {
+                content.push({
+                    type: 'tool_use',
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    input: JSON.parse(toolCall.function.arguments || '{}'),
+                });
+            }
+        }
+    }
+    if (content.length === 0) {
+        content.push({ type: 'text', text: '' });
+    }
+    return {
+        content,
+        stopReason: mapStopReason(choice.finish_reason),
+        usage: response.usage
+            ? {
+                inputTokens: response.usage.prompt_tokens || 0,
+                outputTokens: response.usage.completion_tokens || 0,
+            }
+            : undefined,
+    };
+}
+function mapStopReason(finishReason) {
+    switch (finishReason) {
+        case 'stop':
+            return 'end_turn';
+        case 'length':
+            return 'max_tokens';
+        case 'tool_calls':
+            return 'tool_use';
+        case 'content_filter':
+            return 'stop_sequence';
+        default:
+            return 'end_turn';
+    }
+}

package/dist/electron/electron/agent/llm/openai-oauth.js

@@ -8,11 +8,12 @@ const pi_ai_1 = require("@mariozechner/pi-ai");
  * Convert pi-ai OAuthCredentials to our token format
  */
 function credentialsToTokens(credentials) {
+    const email = typeof credentials.email === 'string' ? credentials.email : undefined;
     return {
         access_token: credentials.access,
         refresh_token: credentials.refresh,
         expires_at: credentials.expires,
-        email: credentials.email,
+        email,
     };
 }
 /**

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

@@ -8,12 +8,12 @@ exports.OpenRouterProvider = void 0;
 class OpenRouterProvider {
     constructor(config) {
         this.type = 'openrouter';
-        this.baseUrl = 'https://openrouter.ai/api/v1';
         const apiKey = config.openrouterApiKey;
         if (!apiKey) {
             throw new Error('OpenRouter API key is required. Configure it in Settings or get one from https://openrouter.ai/keys');
         }
         this.apiKey = apiKey;
+        this.baseUrl = config.openrouterBaseUrl || 'https://openrouter.ai/api/v1';
         this.defaultModel = config.model || 'anthropic/claude-3.5-sonnet';
     }
     async createMessage(request) {