cowork-os 0.3.21 → 0.3.23

package/dist/electron/electron/agent/executor.js

@@ -46,6 +46,7 @@ const pricing_1 = require("./llm/pricing");
 const custom_skill_loader_1 = require("./custom-skill-loader");
 const MemoryService_1 = require("../memory/MemoryService");
 const security_1 = require("./security");
+const builtin_settings_1 = require("./tools/builtin-settings");
 class AwaitingUserInputError extends Error {
     constructor(message) {
         super(message);
@@ -56,7 +57,7 @@ class AwaitingUserInputError extends Error {
 const LLM_TIMEOUT_MS = 2 * 60 * 1000;
 // Per-step timeout (5 minutes max per step)
 const STEP_TIMEOUT_MS = 5 * 60 * 1000;
-// Per-tool execution timeout (45 seconds - balance responsiveness with heavier tools)
+// Default per-tool execution timeout (overrideable per tool)
 const TOOL_TIMEOUT_MS = 30 * 1000;
 // Maximum consecutive failures for the same tool before giving up
 const MAX_TOOL_FAILURES = 2;
@@ -915,6 +916,7 @@ class TaskExecutor {
         // Global turn tracking (across all steps) - similar to Claude Agent SDK's maxTurns
         this.globalTurnCount = 0;
         this.maxGlobalTurns = 100; // Configurable global limit
+        this.lastUserMessage = task.prompt;
         this.requiresTestRun = this.detectTestRequirement(`${task.title}\n${task.prompt}`);
         // Get base settings
         const settings = llm_1.LLMProviderFactory.loadSettings();
@@ -927,7 +929,7 @@ class TaskExecutor {
         // Use task's model key if specified, otherwise use global settings
         const effectiveModelKey = taskModelKey || settings.modelKey;
         // Get the model ID
-        this.modelId = llm_1.LLMProviderFactory.getModelId(effectiveModelKey, settings.providerType, settings.ollama?.model, settings.gemini?.model, settings.openrouter?.model, settings.openai?.model);
+        this.modelId = llm_1.LLMProviderFactory.getModelId(effectiveModelKey, settings.providerType, settings.ollama?.model, settings.gemini?.model, settings.openrouter?.model, settings.openai?.model, settings.groq?.model, settings.xai?.model, settings.kimi?.model, settings.customProviders);
         this.modelKey = effectiveModelKey;
         // Initialize context manager for handling long conversations
         this.contextManager = new context_manager_1.ContextManager(effectiveModelKey);
@@ -1046,6 +1048,20 @@ class TaskExecutor {
         this.iterationCount++;
         this.globalTurnCount++; // Track global turns across all steps
     }
+    getToolTimeoutMs(toolName, input) {
+        const settingsTimeout = builtin_settings_1.BuiltinToolsSettingsManager.getToolTimeoutMs(toolName);
+        const normalizedSettingsTimeout = settingsTimeout && settingsTimeout > 0 ? settingsTimeout : null;
+        if (toolName === 'run_command') {
+            const inputTimeout = typeof input?.timeout === 'number'
+                ? input.timeout
+                : undefined;
+            if (typeof inputTimeout === 'number' && Number.isFinite(inputTimeout) && inputTimeout > 0) {
+                return Math.round(inputTimeout);
+            }
+            return normalizedSettingsTimeout ?? TOOL_TIMEOUT_MS;
+        }
+        return normalizedSettingsTimeout ?? TOOL_TIMEOUT_MS;
+    }
     /**
      * Check if a file operation should be blocked (redundant read or duplicate creation)
      * @returns Object with blocked flag, reason, and suggestion if blocked, plus optional cached result
@@ -1266,6 +1282,33 @@ class TaskExecutor {
         }
         return { input, modified: false };
     }
+    async handleCanvasPushFallback(content, assistantText) {
+        if (content.name !== 'canvas_push') {
+            return;
+        }
+        const inputContent = content.input?.content;
+        const hasContent = typeof inputContent === 'string' && inputContent.trim().length > 0;
+        const filename = content.input?.filename;
+        const isHtmlTarget = !filename || filename === 'index.html';
+        if (hasContent || !isHtmlTarget) {
+            return;
+        }
+        const extracted = this.extractHtmlFromText(assistantText);
+        const generated = extracted || await this.generateCanvasHtml(this.lastUserMessage || this.task.prompt);
+        if (!generated) {
+            return;
+        }
+        content.input = {
+            ...(content.input || {}),
+            content: generated,
+        };
+        this.daemon.logEvent(this.task.id, 'parameter_inference', {
+            tool: content.name,
+            inference: extracted
+                ? 'Recovered HTML from assistant text'
+                : 'Auto-generated HTML from latest user request',
+        });
+    }
     /**
      * Get available tools, filtering out disabled ones
      * This prevents the LLM from trying to use tools that have been disabled by the circuit breaker
@@ -2610,12 +2653,13 @@ SCHEDULING & REMINDERS:
                 this.checkBudgets();
                 // Compact messages if context is getting too large
                 messages = this.contextManager.compactMessages(messages, systemPromptTokens);
+                const availableTools = this.getAvailableTools();
                 // Use retry wrapper for resilient API calls
                 const response = await this.callLLMWithRetry(() => withTimeout(this.provider.createMessage({
                     model: this.modelId,
                     maxTokens: 4096,
                     system: this.systemPrompt,
-                    tools: this.getAvailableTools(),
+                    tools: availableTools,
                     messages,
                     signal: this.abortController.signal,
                 }), LLM_TIMEOUT_MS, 'LLM execution step'), `Step execution (iteration ${iterationCount})`);
@@ -2630,6 +2674,10 @@ SCHEDULING & REMINDERS:
                 }
                 // Log any text responses from the assistant and check if asking a question
                 let assistantAskedQuestion = false;
+                const assistantText = (response.content || [])
+                    .filter((item) => item.type === 'text' && item.text)
+                    .map((item) => item.text)
+                    .join('\n');
                 if (response.content) {
                     for (const content of response.content) {
                         if (content.type === 'text' && content.text) {
@@ -2674,6 +2722,8 @@ SCHEDULING & REMINDERS:
                 const toolResults = [];
                 let hasDisabledToolAttempt = false;
                 let hasDuplicateToolAttempt = false;
+                let hasUnavailableToolAttempt = false;
+                const availableToolNames = new Set(availableTools.map(tool => tool.name));
                 for (const content of response.content || []) {
                     if (content.type === 'tool_use') {
                         // Check if this tool is disabled (circuit breaker tripped)
@@ -2697,6 +2747,37 @@ SCHEDULING & REMINDERS:
                             hasDisabledToolAttempt = true;
                             continue;
                         }
+                        // Validate tool availability before attempting any inference
+                        if (!availableToolNames.has(content.name)) {
+                            console.log(`[TaskExecutor] Tool not available in this context: ${content.name}`);
+                            this.daemon.logEvent(this.task.id, 'tool_error', {
+                                tool: content.name,
+                                error: 'Tool not available in current context or permissions',
+                                blocked: true,
+                            });
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: content.id,
+                                content: JSON.stringify({
+                                    error: `Tool "${content.name}" is not available in this context. Please choose a different tool or check permissions/integrations.`,
+                                    unavailable: true,
+                                }),
+                                is_error: true,
+                            });
+                            hasUnavailableToolAttempt = true;
+                            continue;
+                        }
+                        // Infer missing parameters for weaker models (normalize inputs before deduplication)
+                        const inference = this.inferMissingParameters(content.name, content.input);
+                        if (inference.modified) {
+                            content.input = inference.input;
+                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
+                                tool: content.name,
+                                inference: inference.inference,
+                            });
+                        }
+                        // If canvas_push is missing content, try extracting HTML from assistant text or auto-generate
+                        await this.handleCanvasPushFallback(content, assistantText);
                         // Check for duplicate tool calls (prevents stuck loops)
                         const duplicateCheck = this.toolCallDeduplicator.checkDuplicate(content.name, content.input);
                         if (duplicateCheck.isDuplicate) {
@@ -2767,22 +2848,14 @@ SCHEDULING & REMINDERS:
                             }
                             continue;
                         }
-                        // Infer missing parameters for weaker models
-                        const inference = this.inferMissingParameters(content.name, content.input);
-                        if (inference.modified) {
-                            content.input = inference.input;
-                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
-                                tool: content.name,
-                                inference: inference.inference,
-                            });
-                        }
                         this.daemon.logEvent(this.task.id, 'tool_call', {
                             tool: content.name,
                             input: content.input,
                         });
                         try {
                             // Execute tool with timeout to prevent hanging
-                            const result = await withTimeout(this.toolRegistry.executeTool(content.name, content.input), TOOL_TIMEOUT_MS, `Tool ${content.name}`);
+                            const toolTimeoutMs = this.getToolTimeoutMs(content.name, content.input);
+                            const result = await withTimeout(this.toolRegistry.executeTool(content.name, content.input), toolTimeoutMs, `Tool ${content.name}`);
                             // Tool succeeded - reset failure counter
                             this.toolFailureTracker.recordSuccess(content.name);
                             // Record this call for deduplication
@@ -2882,7 +2955,7 @@ SCHEDULING & REMINDERS:
                     // If all tool attempts were for disabled or duplicate tools, don't continue looping
                     // This prevents infinite retry loops
                     const allToolsFailed = toolResults.every(r => r.is_error);
-                    if ((hasDisabledToolAttempt || hasDuplicateToolAttempt) && allToolsFailed) {
+                    if ((hasDisabledToolAttempt || hasDuplicateToolAttempt || hasUnavailableToolAttempt) && allToolsFailed) {
                         console.log('[TaskExecutor] All tool calls failed, were disabled, or duplicates - stopping iteration');
                         if (hasDuplicateToolAttempt) {
                             // Duplicate detection triggered - step is likely complete
@@ -2993,6 +3066,57 @@ SCHEDULING & REMINDERS:
             });
         }
     }
+    extractHtmlFromText(text) {
+        if (!text)
+            return null;
+        const fenceMatch = text.match(/```html([\s\S]*?)```/i);
+        const raw = fenceMatch ? fenceMatch[1].trim() : text;
+        const doctypeIndex = raw.indexOf('<!DOCTYPE html');
+        if (doctypeIndex >= 0) {
+            const endIndex = raw.lastIndexOf('</html>');
+            if (endIndex > doctypeIndex) {
+                return raw.slice(doctypeIndex, endIndex + '</html>'.length).trim();
+            }
+        }
+        const htmlIndex = raw.indexOf('<html');
+        if (htmlIndex >= 0) {
+            const endIndex = raw.lastIndexOf('</html>');
+            if (endIndex > htmlIndex) {
+                return raw.slice(htmlIndex, endIndex + '</html>'.length).trim();
+            }
+        }
+        return null;
+    }
+    async generateCanvasHtml(prompt) {
+        const system = [
+            'You generate a single self-contained HTML document for an in-app canvas.',
+            'Output ONLY the HTML document (no markdown, no commentary).',
+            'Use inline CSS and JS. Do not reference external assets or remote URLs.',
+            'Keep it reasonably compact and interactive where appropriate.',
+        ].join(' ');
+        try {
+            const response = await this.provider.createMessage({
+                model: this.modelId,
+                maxTokens: 1800,
+                system,
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Build an interactive HTML demo for this request:\n${prompt}`,
+                    },
+                ],
+            });
+            const text = (response.content || [])
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text)
+                .join('\n');
+            return this.extractHtmlFromText(text);
+        }
+        catch (error) {
+            console.error('[TaskExecutor] Failed to auto-generate canvas HTML:', error);
+            return null;
+        }
+    }
     /**
      * Send a follow-up message to continue the conversation
      */
@@ -3003,6 +3127,7 @@ SCHEDULING & REMINDERS:
         let resumeAttempted = false;
         this.waitingForUserInput = false;
         this.paused = false;
+        this.lastUserMessage = message;
         this.toolRegistry.setCanvasSessionCutoff(shouldStartNewCanvasSession ? Date.now() : null);
         this.daemon.updateTaskStatus(this.task.id, 'executing');
         this.daemon.logEvent(this.task.id, 'executing', { message: 'Processing follow-up message' });
@@ -3198,12 +3323,14 @@ SCHEDULING & REMINDERS:
                 this.checkBudgets();
                 // Compact messages if context is getting too large
                 messages = this.contextManager.compactMessages(messages, systemPromptTokens);
+                const availableTools = this.getAvailableTools();
+                const availableToolNames = new Set(availableTools.map(tool => tool.name));
                 // Use retry wrapper for resilient API calls
                 const response = await this.callLLMWithRetry(() => withTimeout(this.provider.createMessage({
                     model: this.modelId,
                     maxTokens: 4096,
                     system: this.systemPrompt,
-                    tools: this.getAvailableTools(),
+                    tools: availableTools,
                     messages,
                     signal: this.abortController.signal,
                 }), LLM_TIMEOUT_MS, 'LLM message processing'), `Message processing (iteration ${iterationCount})`);
@@ -3216,6 +3343,10 @@ SCHEDULING & REMINDERS:
                 // Log any text responses from the assistant and check if asking a question
                 let assistantAskedQuestion = false;
                 let hasTextInThisResponse = false;
+                const assistantText = (response.content || [])
+                    .filter((item) => item.type === 'text' && item.text)
+                    .map((item) => item.text)
+                    .join('\n');
                 if (response.content) {
                     for (const content of response.content) {
                         if (content.type === 'text' && content.text && content.text.trim().length > 0) {
@@ -3262,6 +3393,7 @@ SCHEDULING & REMINDERS:
                 const toolResults = [];
                 let hasDisabledToolAttempt = false;
                 let hasDuplicateToolAttempt = false;
+                let hasUnavailableToolAttempt = false;
                 for (const content of response.content || []) {
                     if (content.type === 'tool_use') {
                         // Check if this tool is disabled (circuit breaker tripped)
@@ -3285,6 +3417,37 @@ SCHEDULING & REMINDERS:
                             hasDisabledToolAttempt = true;
                             continue;
                         }
+                        // Validate tool availability before attempting any inference
+                        if (!availableToolNames.has(content.name)) {
+                            console.log(`[TaskExecutor] Tool not available in this context: ${content.name}`);
+                            this.daemon.logEvent(this.task.id, 'tool_error', {
+                                tool: content.name,
+                                error: 'Tool not available in current context or permissions',
+                                blocked: true,
+                            });
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: content.id,
+                                content: JSON.stringify({
+                                    error: `Tool "${content.name}" is not available in this context. Please choose a different tool or check permissions/integrations.`,
+                                    unavailable: true,
+                                }),
+                                is_error: true,
+                            });
+                            hasUnavailableToolAttempt = true;
+                            continue;
+                        }
+                        // Infer missing parameters for weaker models (normalize inputs before deduplication)
+                        const inference = this.inferMissingParameters(content.name, content.input);
+                        if (inference.modified) {
+                            content.input = inference.input;
+                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
+                                tool: content.name,
+                                inference: inference.inference,
+                            });
+                        }
+                        // If canvas_push is missing content, try extracting HTML from assistant text or auto-generate
+                        await this.handleCanvasPushFallback(content, assistantText);
                         // Check for duplicate tool calls (prevents stuck loops)
                         const duplicateCheck = this.toolCallDeduplicator.checkDuplicate(content.name, content.input);
                         if (duplicateCheck.isDuplicate) {
@@ -3353,22 +3516,14 @@ SCHEDULING & REMINDERS:
                             }
                             continue;
                         }
-                        // Infer missing parameters for weaker models
-                        const inference = this.inferMissingParameters(content.name, content.input);
-                        if (inference.modified) {
-                            content.input = inference.input;
-                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
-                                tool: content.name,
-                                inference: inference.inference,
-                            });
-                        }
                         this.daemon.logEvent(this.task.id, 'tool_call', {
                             tool: content.name,
                             input: content.input,
                         });
                         try {
                             // Execute tool with timeout to prevent hanging
-                            const result = await withTimeout(this.toolRegistry.executeTool(content.name, content.input), TOOL_TIMEOUT_MS, `Tool ${content.name}`);
+                            const toolTimeoutMs = this.getToolTimeoutMs(content.name, content.input);
+                            const result = await withTimeout(this.toolRegistry.executeTool(content.name, content.input), toolTimeoutMs, `Tool ${content.name}`);
                             // Tool succeeded - reset failure counter
                             this.toolFailureTracker.recordSuccess(content.name);
                             // Record this call for deduplication
@@ -3430,7 +3585,7 @@ SCHEDULING & REMINDERS:
                     });
                     // If all tool attempts were for disabled or duplicate tools, don't continue looping
                     const allToolsFailed = toolResults.every(r => r.is_error);
-                    if ((hasDisabledToolAttempt || hasDuplicateToolAttempt) && allToolsFailed) {
+                    if ((hasDisabledToolAttempt || hasDuplicateToolAttempt || hasUnavailableToolAttempt) && allToolsFailed) {
                         console.log('[TaskExecutor] All tool calls failed, were disabled, or duplicates - stopping iteration');
                         continueLoop = false;
                     }

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/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;