cowork-os 0.3.21 → 0.3.25

package/dist/electron/electron/agent/llm/github-copilot-provider.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubCopilotProvider = void 0;
+const openai_compatible_provider_1 = require("./openai-compatible-provider");
+const COPILOT_TOKEN_URL = 'https://api.github.com/copilot_internal/v2/token';
+const DEFAULT_COPILOT_BASE_URL = 'https://api.individual.githubcopilot.com';
+function isTokenValid(cache, now = Date.now()) {
+    return cache.expiresAt - now > 5 * 60 * 1000;
+}
+function parseCopilotTokenResponse(payload) {
+    if (!payload || typeof payload !== 'object') {
+        throw new Error('Unexpected response from Copilot token endpoint');
+    }
+    const token = payload.token;
+    const expiresAt = payload.expires_at;
+    if (typeof token !== 'string' || !token.trim()) {
+        throw new Error('Copilot token response missing token');
+    }
+    if (typeof expiresAt === 'number' && Number.isFinite(expiresAt)) {
+        return { token, expiresAt: expiresAt > 10000000000 ? expiresAt : expiresAt * 1000 };
+    }
+    if (typeof expiresAt === 'string' && expiresAt.trim()) {
+        const parsed = Number.parseInt(expiresAt, 10);
+        if (!Number.isFinite(parsed)) {
+            throw new Error('Copilot token response has invalid expires_at');
+        }
+        return { token, expiresAt: parsed > 10000000000 ? parsed : parsed * 1000 };
+    }
+    throw new Error('Copilot token response missing expires_at');
+}
+function deriveCopilotBaseUrl(token) {
+    const match = token.match(/(?:^|;)\s*proxy-ep=([^;\s]+)/i);
+    const proxyEp = match?.[1]?.trim();
+    if (!proxyEp)
+        return DEFAULT_COPILOT_BASE_URL;
+    const host = proxyEp.replace(/^https?:\/\//, '').replace(/^proxy\./i, 'api.');
+    return host ? `https://${host}` : DEFAULT_COPILOT_BASE_URL;
+}
+class GitHubCopilotProvider {
+    constructor(config) {
+        this.type = 'github-copilot';
+        const token = config.providerApiKey;
+        if (!token) {
+            throw new Error('GitHub token is required for Copilot. Configure it in Settings.');
+        }
+        this.githubToken = token;
+        this.model = config.model || 'gpt-4o';
+    }
+    async createMessage(request) {
+        const client = await this.getClient(request.model || this.model);
+        return client.createMessage(request);
+    }
+    async testConnection() {
+        try {
+            const client = await this.getClient(this.model);
+            return await client.testConnection();
+        }
+        catch (error) {
+            return { success: false, error: error.message || 'Failed to connect to Copilot' };
+        }
+    }
+    async getClient(model) {
+        const auth = await this.getCopilotAuth();
+        return new openai_compatible_provider_1.OpenAICompatibleProvider({
+            type: 'github-copilot',
+            providerName: 'GitHub Copilot',
+            apiKey: auth.token,
+            baseUrl: auth.baseUrl,
+            defaultModel: model,
+        });
+    }
+    async getCopilotAuth() {
+        if (GitHubCopilotProvider.cache && isTokenValid(GitHubCopilotProvider.cache)) {
+            return GitHubCopilotProvider.cache;
+        }
+        const response = await fetch(COPILOT_TOKEN_URL, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${this.githubToken}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Copilot token exchange failed: HTTP ${response.status}`);
+        }
+        const json = await response.json();
+        const parsed = parseCopilotTokenResponse(json);
+        const cache = {
+            token: parsed.token,
+            expiresAt: parsed.expiresAt,
+            baseUrl: deriveCopilotBaseUrl(parsed.token),
+        };
+        GitHubCopilotProvider.cache = cache;
+        return cache;
+    }
+}
+exports.GitHubCopilotProvider = GitHubCopilotProvider;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqProvider = void 0;
+const openai_compatible_provider_1 = require("./openai-compatible-provider");
+const GROQ_BASE_URL = 'https://api.groq.com/openai/v1';
+const DEFAULT_GROQ_MODEL = 'llama-3.1-8b-instant';
+class GroqProvider {
+    constructor(config) {
+        this.type = 'groq';
+        const apiKey = config.groqApiKey;
+        if (!apiKey) {
+            throw new Error('Groq API key is required. Configure it in Settings.');
+        }
+        const baseUrl = config.groqBaseUrl || GROQ_BASE_URL;
+        this.client = new openai_compatible_provider_1.OpenAICompatibleProvider({
+            type: 'groq',
+            providerName: 'Groq',
+            apiKey,
+            baseUrl,
+            defaultModel: config.model || DEFAULT_GROQ_MODEL,
+        });
+    }
+    createMessage(request) {
+        return this.client.createMessage(request);
+    }
+    testConnection() {
+        return this.client.testConnection();
+    }
+    getAvailableModels() {
+        return this.client.getAvailableModels();
+    }
+}
+exports.GroqProvider = GroqProvider;

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.AzureOpenAIProvider = 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,18 @@ 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 azure_openai_provider_1 = require("./azure-openai-provider");
+Object.defineProperty(exports, "AzureOpenAIProvider", { enumerable: true, get: function () { return azure_openai_provider_1.AzureOpenAIProvider; } });
+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) {