cowork-os 0.3.21 → 0.3.25

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

@@ -45,10 +45,87 @@ const ollama_provider_1 = require("./ollama-provider");
 const gemini_provider_1 = require("./gemini-provider");
 const openrouter_provider_1 = require("./openrouter-provider");
 const openai_provider_1 = require("./openai-provider");
+const azure_openai_provider_1 = require("./azure-openai-provider");
+const groq_provider_1 = require("./groq-provider");
+const xai_provider_1 = require("./xai-provider");
+const kimi_provider_1 = require("./kimi-provider");
+const anthropic_compatible_provider_1 = require("./anthropic-compatible-provider");
+const openai_compatible_provider_1 = require("./openai-compatible-provider");
+const github_copilot_provider_1 = require("./github-copilot-provider");
 const SecureSettingsRepository_1 = require("../../database/SecureSettingsRepository");
+const llm_provider_catalog_1 = require("../../../shared/llm-provider-catalog");
 const LEGACY_SETTINGS_FILE = 'llm-settings.json';
 const MASKED_VALUE = '***configured***';
 const ENCRYPTED_PREFIX = 'encrypted:';
+const CUSTOM_PROVIDER_ALIASES = {
+    'kimi-coding': 'kimi-code',
+};
+function resolveCustomProviderId(providerType) {
+    return CUSTOM_PROVIDER_ALIASES[providerType] || providerType;
+}
+function getCustomProviderEntry(providerType) {
+    return llm_provider_catalog_1.CUSTOM_PROVIDER_MAP.get(resolveCustomProviderId(providerType));
+}
+function getCustomProviderConfig(customProviders, providerType) {
+    if (!customProviders)
+        return undefined;
+    const resolved = resolveCustomProviderId(providerType);
+    const resolvedConfig = customProviders[resolved];
+    if (resolvedConfig) {
+        return resolvedConfig;
+    }
+    const fallbackConfig = customProviders[providerType];
+    if (fallbackConfig && resolved !== providerType) {
+        console.log(`[LLMProviderFactory] Custom provider config not found for "${resolved}", falling back to "${providerType}".`);
+    }
+    return fallbackConfig;
+}
+function isCustomProviderConfigured(entry, config) {
+    if (!config)
+        return false;
+    const hasApiKey = !!config.apiKey?.trim();
+    const hasBaseUrl = !!config.baseUrl?.trim() || !!entry.baseUrl;
+    const hasUserConfig = hasApiKey || !!config.baseUrl?.trim() || !!config.model?.trim();
+    if (!hasUserConfig)
+        return false;
+    if (entry.apiKeyOptional) {
+        return entry.requiresBaseUrl ? hasBaseUrl : hasApiKey || hasBaseUrl;
+    }
+    return entry.requiresBaseUrl ? hasApiKey && hasBaseUrl : hasApiKey;
+}
+function createCustomProvider(config, entry, resolvedType) {
+    if (resolvedType === 'github-copilot') {
+        return new github_copilot_provider_1.GitHubCopilotProvider(config);
+    }
+    const apiKey = config.providerApiKey || '';
+    const baseUrl = config.providerBaseUrl || entry.baseUrl || '';
+    if (entry.requiresBaseUrl && !baseUrl) {
+        throw new Error(`${entry.name} base URL is required. Configure it in Settings.`);
+    }
+    if (!apiKey && !entry.apiKeyOptional) {
+        throw new Error(`${entry.name} API key is required. Configure it in Settings.`);
+    }
+    const model = config.model || entry.defaultModel;
+    if (!model) {
+        throw new Error(`${entry.name} model is required. Configure it in Settings.`);
+    }
+    if (entry.compatibility === 'openai') {
+        return new openai_compatible_provider_1.OpenAICompatibleProvider({
+            type: resolvedType,
+            providerName: entry.name,
+            apiKey,
+            baseUrl,
+            defaultModel: model,
+        });
+    }
+    return new anthropic_compatible_provider_1.AnthropicCompatibleProvider({
+        type: resolvedType,
+        providerName: entry.name,
+        apiKey,
+        baseUrl,
+        defaultModel: model,
+    });
+}
 // ============ Legacy Encryption Functions (for migration only) ============
 // These functions are only used to decrypt settings from legacy JSON files
 // during migration to the encrypted database. New settings use full-object
@@ -178,6 +255,40 @@ function sanitizeSettings(settings) {
             refreshToken: decryptedRefreshToken,
         };
     }
+    if (sanitized.azure) {
+        sanitized.azure = {
+            ...sanitized.azure,
+            apiKey: decryptSecret(sanitized.azure.apiKey),
+        };
+    }
+    if (sanitized.groq) {
+        sanitized.groq = {
+            ...sanitized.groq,
+            apiKey: decryptSecret(sanitized.groq.apiKey),
+        };
+    }
+    if (sanitized.xai) {
+        sanitized.xai = {
+            ...sanitized.xai,
+            apiKey: decryptSecret(sanitized.xai.apiKey),
+        };
+    }
+    if (sanitized.kimi) {
+        sanitized.kimi = {
+            ...sanitized.kimi,
+            apiKey: decryptSecret(sanitized.kimi.apiKey),
+        };
+    }
+    if (sanitized.customProviders) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(sanitized.customProviders)) {
+            normalized[key] = {
+                ...value,
+                apiKey: decryptSecret(value.apiKey),
+            };
+        }
+        sanitized.customProviders = normalized;
+    }
     return sanitized;
 }
 const DEFAULT_SETTINGS = {
@@ -188,6 +299,20 @@ const DEFAULT_SETTINGS = {
  * Factory for creating LLM providers
  */
 class LLMProviderFactory {
+    static normalizeCustomProviders(settings) {
+        if (!settings.customProviders)
+            return;
+        const legacyKey = settings.customProviders['kimi-coding'];
+        if (legacyKey && !settings.customProviders['kimi-code']) {
+            settings.customProviders['kimi-code'] = legacyKey;
+        }
+        if (settings.customProviders['kimi-coding']) {
+            delete settings.customProviders['kimi-coding'];
+        }
+        if (settings.providerType === 'kimi-coding') {
+            settings.providerType = 'kimi-code';
+        }
+    }
     /**
      * Initialize the factory
      */
@@ -270,6 +395,7 @@ class LLMProviderFactory {
                 const stored = repository.load('llm');
                 if (stored) {
                     settings = { ...DEFAULT_SETTINGS, ...stored };
+                    this.normalizeCustomProviders(settings);
                     settingsExist = true;
                 }
             }
@@ -307,12 +433,33 @@ class LLMProviderFactory {
         if (settings.openai?.apiKey || settings.openai?.accessToken) {
             return 'openai';
         }
+        const azureDeployment = settings.azure?.deployment || settings.azure?.deployments?.[0];
+        if (settings.azure?.apiKey && settings.azure?.endpoint && azureDeployment) {
+            return 'azure';
+        }
+        if (settings.groq?.apiKey) {
+            return 'groq';
+        }
+        if (settings.xai?.apiKey) {
+            return 'xai';
+        }
+        if (settings.kimi?.apiKey) {
+            return 'kimi';
+        }
         if (settings.bedrock?.accessKeyId || settings.bedrock?.profile) {
             return 'bedrock';
         }
         if (settings.ollama?.baseUrl || settings.ollama?.model) {
             return 'ollama';
         }
+        if (settings.customProviders) {
+            for (const entry of llm_provider_catalog_1.CUSTOM_PROVIDER_CATALOG) {
+                const config = getCustomProviderConfig(settings.customProviders, entry.id);
+                if (isCustomProviderConfigured(entry, config)) {
+                    return entry.id;
+                }
+            }
+        }
         // No valid credentials detected - user needs to configure via Settings
         return null;
     }
@@ -350,9 +497,13 @@ class LLMProviderFactory {
     static createProvider(overrideConfig) {
         const settings = this.loadSettings();
         const providerType = overrideConfig?.type || settings.providerType;
+        const customConfig = getCustomProviderConfig(settings.customProviders, providerType);
+        const azureDeployment = overrideConfig?.azureDeployment
+            || settings.azure?.deployment
+            || settings.azure?.deployments?.[0];
         const config = {
             type: providerType,
-            model: this.getModelId(settings.modelKey, providerType, settings.ollama?.model, settings.gemini?.model, settings.openrouter?.model, settings.openai?.model),
+            model: this.getModelId(settings.modelKey, providerType, settings.ollama?.model, settings.gemini?.model, settings.openrouter?.model, settings.openai?.model, azureDeployment, settings.groq?.model, settings.xai?.model, settings.kimi?.model, settings.customProviders),
             // Anthropic config - from settings only
             anthropicApiKey: normalizeSecret(overrideConfig?.anthropicApiKey) || settings.anthropic?.apiKey,
             // Bedrock config - from settings only
@@ -368,11 +519,29 @@ class LLMProviderFactory {
             geminiApiKey: normalizeSecret(overrideConfig?.geminiApiKey) || settings.gemini?.apiKey,
             // OpenRouter config - from settings only
             openrouterApiKey: normalizeSecret(overrideConfig?.openrouterApiKey) || settings.openrouter?.apiKey,
+            openrouterBaseUrl: overrideConfig?.openrouterBaseUrl || settings.openrouter?.baseUrl,
             // OpenAI config - from settings only
             openaiApiKey: normalizeSecret(overrideConfig?.openaiApiKey) || settings.openai?.apiKey,
             openaiAccessToken: normalizeSecret(overrideConfig?.openaiAccessToken) || settings.openai?.accessToken,
             openaiRefreshToken: settings.openai?.refreshToken,
             openaiTokenExpiresAt: settings.openai?.tokenExpiresAt,
+            // Azure OpenAI config - from settings only
+            azureApiKey: normalizeSecret(overrideConfig?.azureApiKey) || settings.azure?.apiKey,
+            azureEndpoint: overrideConfig?.azureEndpoint || settings.azure?.endpoint,
+            azureDeployment,
+            azureApiVersion: overrideConfig?.azureApiVersion || settings.azure?.apiVersion,
+            // Groq config - from settings only
+            groqApiKey: normalizeSecret(overrideConfig?.groqApiKey) || settings.groq?.apiKey,
+            groqBaseUrl: overrideConfig?.groqBaseUrl || settings.groq?.baseUrl,
+            // xAI config - from settings only
+            xaiApiKey: normalizeSecret(overrideConfig?.xaiApiKey) || settings.xai?.apiKey,
+            xaiBaseUrl: overrideConfig?.xaiBaseUrl || settings.xai?.baseUrl,
+            // Kimi config - from settings only
+            kimiApiKey: normalizeSecret(overrideConfig?.kimiApiKey) || settings.kimi?.apiKey,
+            kimiBaseUrl: overrideConfig?.kimiBaseUrl || settings.kimi?.baseUrl,
+            // Custom provider config
+            providerApiKey: normalizeSecret(overrideConfig?.providerApiKey) || customConfig?.apiKey,
+            providerBaseUrl: overrideConfig?.providerBaseUrl || customConfig?.baseUrl,
         };
         return this.createProviderFromConfig(config);
     }
@@ -380,6 +549,11 @@ class LLMProviderFactory {
      * Create a provider from explicit config
      */
     static createProviderFromConfig(config) {
+        const customEntry = getCustomProviderEntry(config.type);
+        if (customEntry) {
+            const resolvedType = resolveCustomProviderId(config.type);
+            return createCustomProvider(config, customEntry, resolvedType);
+        }
         switch (config.type) {
             case 'anthropic':
                 return new anthropic_provider_1.AnthropicProvider(config);
@@ -393,6 +567,14 @@ class LLMProviderFactory {
                 return new openrouter_provider_1.OpenRouterProvider(config);
             case 'openai':
                 return new openai_provider_1.OpenAIProvider(config);
+            case 'azure':
+                return new azure_openai_provider_1.AzureOpenAIProvider(config);
+            case 'groq':
+                return new groq_provider_1.GroqProvider(config);
+            case 'xai':
+                return new xai_provider_1.XAIProvider(config);
+            case 'kimi':
+                return new kimi_provider_1.KimiProvider(config);
             default:
                 throw new Error(`Unknown provider type: ${config.type}`);
         }
@@ -400,7 +582,12 @@ class LLMProviderFactory {
     /**
      * Get the model ID for a provider
      */
-    static getModelId(modelKey, providerType, ollamaModel, geminiModel, openrouterModel, openaiModel) {
+    static getModelId(modelKey, providerType, ollamaModel, geminiModel, openrouterModel, openaiModel, azureDeployment, groqModel, xaiModel, kimiModel, customProviders) {
+        const customEntry = getCustomProviderEntry(providerType);
+        if (customEntry) {
+            const customConfig = getCustomProviderConfig(customProviders, providerType);
+            return customConfig?.model || customEntry.defaultModel;
+        }
         // For Ollama, use the specific Ollama model if provided
         if (providerType === 'ollama') {
             return ollamaModel || 'gpt-oss:20b';
@@ -417,6 +604,22 @@ class LLMProviderFactory {
         if (providerType === 'openai') {
             return openaiModel || 'gpt-4o-mini';
         }
+        // For Azure OpenAI, use the deployment name
+        if (providerType === 'azure') {
+            return azureDeployment || '';
+        }
+        // For Groq, use the specific model if provided or default
+        if (providerType === 'groq') {
+            return groqModel || 'llama-3.1-8b-instant';
+        }
+        // For xAI, use the specific model if provided or default
+        if (providerType === 'xai') {
+            return xaiModel || 'grok-4-fast-non-reasoning';
+        }
+        // For Kimi, use the specific model if provided or default
+        if (providerType === 'kimi') {
+            return kimiModel || 'kimi-k2.5';
+        }
         // For other providers, look up in MODELS
         const model = types_1.MODELS[modelKey];
         if (!model) {
@@ -445,7 +648,7 @@ class LLMProviderFactory {
      */
     static getAvailableProviders() {
         const settings = this.loadSettings();
-        return [
+        const builtIns = [
             {
                 type: 'anthropic',
                 name: 'Anthropic API',
@@ -466,6 +669,28 @@ class LLMProviderFactory {
                 name: 'OpenAI',
                 configured: !!(settings.openai?.apiKey || settings.openai?.accessToken),
             },
+            {
+                type: 'azure',
+                name: 'Azure OpenAI',
+                configured: !!(settings.azure?.apiKey
+                    && settings.azure?.endpoint
+                    && (settings.azure?.deployment || settings.azure?.deployments?.length)),
+            },
+            {
+                type: 'groq',
+                name: 'Groq',
+                configured: !!settings.groq?.apiKey,
+            },
+            {
+                type: 'xai',
+                name: 'xAI (Grok)',
+                configured: !!settings.xai?.apiKey,
+            },
+            {
+                type: 'kimi',
+                name: 'Kimi',
+                configured: !!settings.kimi?.apiKey,
+            },
             {
                 type: 'bedrock',
                 name: 'AWS Bedrock',
@@ -477,6 +702,15 @@ class LLMProviderFactory {
                 configured: !!(settings.ollama?.baseUrl || settings.ollama?.model),
             },
         ];
+        const customProviders = llm_provider_catalog_1.CUSTOM_PROVIDER_CATALOG.map((entry) => {
+            const config = getCustomProviderConfig(settings.customProviders, entry.id);
+            return {
+                type: entry.id,
+                name: entry.name,
+                configured: isCustomProviderConfigured(entry, config),
+            };
+        });
+        return [...builtIns, ...customProviders];
     }
     /**
      * Get current configuration status
@@ -645,11 +879,13 @@ class LLMProviderFactory {
     /**
      * Fetch available OpenRouter models from the API
      */
-    static async getOpenRouterModels(apiKey) {
+    static async getOpenRouterModels(apiKey, baseUrl) {
         const settings = this.loadSettings();
         // Normalize empty strings to undefined
         const normalizedApiKey = apiKey?.trim() || undefined;
         const key = normalizedApiKey || settings.openrouter?.apiKey;
+        const normalizedBaseUrl = baseUrl?.trim() || undefined;
+        const resolvedBaseUrl = normalizedBaseUrl || settings.openrouter?.baseUrl;
         const defaultModels = [
             { id: 'anthropic/claude-3.5-sonnet', name: 'Claude 3.5 Sonnet', context_length: 200000 },
             { id: 'anthropic/claude-3-opus', name: 'Claude 3 Opus', context_length: 200000 },
@@ -667,6 +903,7 @@ class LLMProviderFactory {
                 type: 'openrouter',
                 model: '',
                 openrouterApiKey: key,
+                openrouterBaseUrl: resolvedBaseUrl,
             });
             return await provider.getAvailableModels();
         }
@@ -758,6 +995,100 @@ class LLMProviderFactory {
             return defaultModels;
         }
     }
+    /**
+     * Fetch available Groq models from the API
+     */
+    static async getGroqModels(apiKey, baseUrl) {
+        const settings = this.loadSettings();
+        const normalizedApiKey = apiKey?.trim() || undefined;
+        const key = normalizedApiKey || settings.groq?.apiKey;
+        const normalizedBaseUrl = baseUrl?.trim() || undefined;
+        const resolvedBaseUrl = normalizedBaseUrl || settings.groq?.baseUrl;
+        const defaultModels = [
+            { id: 'llama-3.1-8b-instant', name: 'Llama 3.1 8B Instant' },
+            { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B Versatile' },
+        ];
+        if (!key) {
+            return defaultModels;
+        }
+        try {
+            const provider = new groq_provider_1.GroqProvider({
+                type: 'groq',
+                model: '',
+                groqApiKey: key,
+                groqBaseUrl: resolvedBaseUrl,
+            });
+            return await provider.getAvailableModels();
+        }
+        catch (error) {
+            console.error('Failed to fetch Groq models:', error);
+            return defaultModels;
+        }
+    }
+    /**
+     * Fetch available xAI models from the API
+     */
+    static async getXAIModels(apiKey, baseUrl) {
+        const settings = this.loadSettings();
+        const normalizedApiKey = apiKey?.trim() || undefined;
+        const key = normalizedApiKey || settings.xai?.apiKey;
+        const normalizedBaseUrl = baseUrl?.trim() || undefined;
+        const resolvedBaseUrl = normalizedBaseUrl || settings.xai?.baseUrl;
+        const defaultModels = [
+            { id: 'grok-4', name: 'Grok 4' },
+            { id: 'grok-4-fast-non-reasoning', name: 'Grok 4 Fast (Non-Reasoning)' },
+            { id: 'grok-4-fast-reasoning', name: 'Grok 4 Fast (Reasoning)' },
+        ];
+        if (!key) {
+            return defaultModels;
+        }
+        try {
+            const provider = new xai_provider_1.XAIProvider({
+                type: 'xai',
+                model: '',
+                xaiApiKey: key,
+                xaiBaseUrl: resolvedBaseUrl,
+            });
+            return await provider.getAvailableModels();
+        }
+        catch (error) {
+            console.error('Failed to fetch xAI models:', error);
+            return defaultModels;
+        }
+    }
+    /**
+     * Fetch available Kimi models from the API
+     */
+    static async getKimiModels(apiKey, baseUrl) {
+        const settings = this.loadSettings();
+        const normalizedApiKey = apiKey?.trim() || undefined;
+        const key = normalizedApiKey || settings.kimi?.apiKey;
+        const normalizedBaseUrl = baseUrl?.trim() || undefined;
+        const resolvedBaseUrl = normalizedBaseUrl || settings.kimi?.baseUrl;
+        const defaultModels = [
+            { id: 'kimi-k2.5', name: 'Kimi K2.5' },
+            { id: 'kimi-k2-0905-preview', name: 'Kimi K2.5 Preview' },
+            { id: 'kimi-k2-turbo-preview', name: 'Kimi K2 Turbo (Preview)' },
+            { id: 'kimi-k2-thinking', name: 'Kimi K2 Thinking' },
+            { id: 'kimi-k2-thinking-turbo', name: 'Kimi K2 Thinking Turbo' },
+        ];
+        if (!key) {
+            return defaultModels;
+        }
+        try {
+            const provider = new kimi_provider_1.KimiProvider({
+                type: 'kimi',
+                model: '',
+                kimiApiKey: key,
+                kimiBaseUrl: resolvedBaseUrl,
+            });
+            return await provider.getAvailableModels();
+        }
+        catch (error) {
+            console.error('Failed to fetch Kimi models:', error);
+            return defaultModels;
+        }
+    }
     /**
      * Format OpenAI model ID to display name
      */
@@ -851,6 +1182,15 @@ class LLMProviderFactory {
             case 'openai':
                 settings.cachedOpenAIModels = models;
                 break;
+            case 'groq':
+                settings.cachedGroqModels = models;
+                break;
+            case 'xai':
+                settings.cachedXaiModels = models;
+                break;
+            case 'kimi':
+                settings.cachedKimiModels = models;
+                break;
         }
         this.saveSettings(settings);
     }
@@ -870,6 +1210,12 @@ class LLMProviderFactory {
                 return settings.cachedBedrockModels;
             case 'openai':
                 return settings.cachedOpenAIModels;
+            case 'groq':
+                return settings.cachedGroqModels;
+            case 'xai':
+                return settings.cachedXaiModels;
+            case 'kimi':
+                return settings.cachedKimiModels;
             default:
                 return undefined;
         }

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

@@ -4,7 +4,7 @@
  * Allows switching between Anthropic API and AWS Bedrock
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MODEL = exports.OLLAMA_MODELS = exports.OPENAI_MODELS = exports.OPENROUTER_MODELS = exports.GEMINI_MODELS = exports.MODELS = void 0;
+exports.DEFAULT_MODEL = exports.OLLAMA_MODELS = exports.KIMI_MODELS = exports.XAI_MODELS = exports.GROQ_MODELS = exports.OPENAI_MODELS = exports.OPENROUTER_MODELS = exports.GEMINI_MODELS = exports.MODELS = void 0;
 /**
  * Available AI models with their IDs for each provider
  * Note: Bedrock uses inference profile IDs (us. prefix) for newer models
@@ -159,6 +159,71 @@ exports.OPENAI_MODELS = {
         description: 'Fast reasoning model',
     },
 };
+/**
+ * Popular Groq models
+ */
+exports.GROQ_MODELS = {
+    'llama-3.1-8b-instant': {
+        id: 'llama-3.1-8b-instant',
+        displayName: 'Llama 3.1 8B Instant',
+        description: 'Fast, cost-efficient Groq model',
+    },
+    'llama-3.3-70b-versatile': {
+        id: 'llama-3.3-70b-versatile',
+        displayName: 'Llama 3.3 70B Versatile',
+        description: 'Higher capability Groq model',
+    },
+};
+/**
+ * Popular xAI (Grok) models
+ */
+exports.XAI_MODELS = {
+    'grok-4': {
+        id: 'grok-4',
+        displayName: 'Grok 4',
+        description: 'Flagship model',
+    },
+    'grok-4-fast-non-reasoning': {
+        id: 'grok-4-fast-non-reasoning',
+        displayName: 'Grok 4 Fast (Non-Reasoning)',
+        description: 'Fast responses without explicit reasoning',
+    },
+    'grok-4-fast-reasoning': {
+        id: 'grok-4-fast-reasoning',
+        displayName: 'Grok 4 Fast (Reasoning)',
+        description: 'Faster model with reasoning support',
+    },
+};
+/**
+ * Kimi (Moonshot) models
+ */
+exports.KIMI_MODELS = {
+    'kimi-k2.5': {
+        id: 'kimi-k2.5',
+        displayName: 'Kimi K2.5',
+        description: 'Latest Kimi K2.5 model',
+    },
+    'kimi-k2-0905-preview': {
+        id: 'kimi-k2-0905-preview',
+        displayName: 'Kimi K2.5 Preview',
+        description: 'Preview K2.5 model',
+    },
+    'kimi-k2-turbo-preview': {
+        id: 'kimi-k2-turbo-preview',
+        displayName: 'Kimi K2 Turbo (Preview)',
+        description: 'Faster K2 preview model',
+    },
+    'kimi-k2-thinking': {
+        id: 'kimi-k2-thinking',
+        displayName: 'Kimi K2 Thinking',
+        description: 'Reasoning-focused K2 model',
+    },
+    'kimi-k2-thinking-turbo': {
+        id: 'kimi-k2-thinking-turbo',
+        displayName: 'Kimi K2 Thinking Turbo',
+        description: 'Faster reasoning K2 model',
+    },
+};
 /**
  * Popular Ollama models with their details
  * Users can use any model available on their Ollama server

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XAIProvider = void 0;
+const openai_compatible_provider_1 = require("./openai-compatible-provider");
+const XAI_BASE_URL = 'https://api.x.ai/v1';
+const DEFAULT_XAI_MODEL = 'grok-4-fast-non-reasoning';
+class XAIProvider {
+    constructor(config) {
+        this.type = 'xai';
+        const apiKey = config.xaiApiKey;
+        if (!apiKey) {
+            throw new Error('xAI API key is required. Configure it in Settings.');
+        }
+        const baseUrl = config.xaiBaseUrl || XAI_BASE_URL;
+        this.client = new openai_compatible_provider_1.OpenAICompatibleProvider({
+            type: 'xai',
+            providerName: 'xAI',
+            apiKey,
+            baseUrl,
+            defaultModel: config.model || DEFAULT_XAI_MODEL,
+        });
+    }
+    createMessage(request) {
+        return this.client.createMessage(request);
+    }
+    testConnection() {
+        return this.client.testConnection();
+    }
+    getAvailableModels() {
+        return this.client.getAvailableModels();
+    }
+}
+exports.XAIProvider = XAIProvider;

package/dist/electron/electron/agent/search/provider-factory.js

@@ -52,6 +52,42 @@ const DEFAULT_SETTINGS = {
  * Factory for creating Search providers with fallback support
  */
 class SearchProviderFactory {
+    static async sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    static isTransientSearchError(error) {
+        const message = String(error?.message || '');
+        return (/rate limit/i.test(message) ||
+            /429/.test(message) ||
+            /too many requests/i.test(message) ||
+            /timeout/i.test(message) ||
+            /ETIMEDOUT/i.test(message) ||
+            /ECONNRESET/i.test(message) ||
+            /EAI_AGAIN/i.test(message) ||
+            /503/.test(message) ||
+            /502/.test(message) ||
+            /504/.test(message) ||
+            /service unavailable/i.test(message));
+    }
+    static async searchWithRetry(provider, query, maxAttempts = 3) {
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await provider.search(query);
+            }
+            catch (error) {
+                lastError = error;
+                if (!this.isTransientSearchError(error) || attempt === maxAttempts) {
+                    throw error;
+                }
+                // Exponential backoff with jitter: ~1s, ~2s, ~4s
+                const baseDelay = 1000 * Math.pow(2, attempt - 1);
+                const jitter = Math.random() * 500;
+                await this.sleep(baseDelay + jitter);
+            }
+        }
+        throw lastError || new Error('Search failed');
+    }
     /**
      * Initialize the factory
      */
@@ -288,7 +324,7 @@ class SearchProviderFactory {
         try {
             const primaryConfig = this.getProviderConfig(primaryType);
             const primaryProvider = this.createProviderFromConfig(primaryConfig);
-            return await primaryProvider.search(query);
+            return await this.searchWithRetry(primaryProvider, query);
         }
         catch (primaryError) {
             console.error(`Primary search provider (${primaryType}) failed:`, primaryError.message);
@@ -303,7 +339,7 @@ class SearchProviderFactory {
                 try {
                     const fallbackConfig = this.getProviderConfig(fallbackType);
                     const fallbackProvider = this.createProviderFromConfig(fallbackConfig);
-                    const response = await fallbackProvider.search(query);
+                    const response = await this.searchWithRetry(fallbackProvider, query);
                     // Indicate this came from fallback
                     console.log(`Fallback search with ${fallbackType} succeeded`);
                     return response;