@pheem49/mint 1.2.4 → 1.4.0

package/src/UI/settings.js

@@ -16,6 +16,7 @@ const DEFAULT_CONFIG = {
     ollamaModel: 'llama3:latest',
     enableVoiceReply: true,
     enableCustomWorkflows: true,
+    enableAgentCollaboration: true,
     ttsProvider: 'google',
     ttsVolume: 1.0,
     ttsSpeed: 1.0,
@@ -23,7 +24,8 @@ const DEFAULT_CONFIG = {
     pluginSpotifyEnabled: true,
     pluginCalendarEnabled: false,
     pluginDiscordEnabled: false,
-    showDesktopWidget: true
+    showDesktopWidget: true,
+    mcpServers: {}
 };
 
 let currentConfig = { ...DEFAULT_CONFIG };
@@ -56,6 +58,18 @@ function applyConfig(config) {
     // Apply API key
     document.getElementById('api-key-input').value = config.apiKey || '';
 
+    const anthropicInput = document.getElementById('anthropic-api-key-input');
+    if (anthropicInput) anthropicInput.value = config.anthropicApiKey || '';
+
+    const openaiInput = document.getElementById('openai-api-key-input');
+    if (openaiInput) openaiInput.value = config.openaiApiKey || '';
+
+    const hfInput = document.getElementById('hf-api-key');
+    if (hfInput) hfInput.value = config.hfApiKey || '';
+
+    const ollamaHostInput = document.getElementById('ollama-host-input');
+    if (ollamaHostInput) ollamaHostInput.value = config.ollamaHost || 'http://localhost:11434';
+
     // Apply Gemini model
     applyModelSelection(config.geminiModel);
     
@@ -71,6 +85,24 @@ function applyConfig(config) {
         ollamaInput.value = config.ollamaModel || 'llama3:latest';
     }
 
+    applyModelSelectionGeneric('openai-model-select', 'openai-model-custom-row', 'openai-model-custom', config.openaiModel || 'gpt-4o');
+    applyModelSelectionGeneric('anthropic-model-select', 'anthropic-model-custom-row', 'anthropic-model-custom', config.anthropicModel || 'claude-3-5-sonnet-latest');
+
+    const hfModelInput = document.getElementById('hf-model-name');
+    if (hfModelInput) {
+        hfModelInput.value = config.hfModel || 'meta-llama/Meta-Llama-3-8B-Instruct';
+    }
+
+    const localApiBaseUrlInput = document.getElementById('local-api-base-url');
+    if (localApiBaseUrlInput) {
+        localApiBaseUrlInput.value = config.localApiBaseUrl || 'http://localhost:1234/v1';
+    }
+
+    const localModelNameInput = document.getElementById('local-model-name');
+    if (localModelNameInput) {
+        localModelNameInput.value = config.localModelName || 'local-model';
+    }
+
     const voiceReplyToggle = document.getElementById('enable-voice-reply');
     if (voiceReplyToggle) {
         voiceReplyToggle.checked = config.enableVoiceReply !== false;
@@ -102,6 +134,11 @@ function applyConfig(config) {
         enableWorkflowsToggle.checked = config.enableCustomWorkflows !== false;
     }
 
+    const enableAgentCollaborationToggle = document.getElementById('enable-agent-collaboration');
+    if (enableAgentCollaborationToggle) {
+        enableAgentCollaborationToggle.checked = config.enableAgentCollaboration !== false;
+    }
+
     // Plugins logic
     updatePluginButton('spotify', config.pluginSpotifyEnabled);
     updatePluginButton('calendar', config.pluginCalendarEnabled);
@@ -153,6 +190,9 @@ function applyConfig(config) {
     document.getElementById('proactive-cooldown').value = cooldown;
     updateIntervalDisplay(interval);
     updateCooldownDisplay(cooldown);
+
+    // MCP Servers
+    renderMcpServers();
 }
 
 function lightenColor(hex, amount) {
@@ -164,9 +204,15 @@ function lightenColor(hex, amount) {
 }
 
 function applyModelSelection(model) {
-    const select = document.getElementById('gemini-model-select');
-    const customRow = document.getElementById('gemini-model-custom-row');
-    const customInput = document.getElementById('gemini-model-custom');
+    applyModelSelectionGeneric('gemini-model-select', 'gemini-model-custom-row', 'gemini-model-custom', model);
+}
+
+function applyModelSelectionGeneric(selectId, customRowId, customInputId, model) {
+    const select = document.getElementById(selectId);
+    const customRow = document.getElementById(customRowId);
+    const customInput = document.getElementById(customInputId);
+    if (!select || !customRow || !customInput) return;
+
     const normalized = (model || '').trim();
     const optionValues = Array.from(select.options).map(opt => opt.value);
 
@@ -182,11 +228,16 @@ function applyModelSelection(model) {
 }
 
 function getSelectedModel() {
-    const select = document.getElementById('gemini-model-select');
-    const customInput = document.getElementById('gemini-model-custom');
+    return getSelectedModelGeneric('gemini-model-select', 'gemini-model-custom', DEFAULT_CONFIG.geminiModel);
+}
+
+function getSelectedModelGeneric(selectId, customInputId, defaultModel) {
+    const select = document.getElementById(selectId);
+    const customInput = document.getElementById(customInputId);
+    if (!select || !customInput) return defaultModel;
     if (select.value === 'custom') {
         const custom = (customInput.value || '').trim();
-        return custom || DEFAULT_CONFIG.geminiModel;
+        return custom || defaultModel;
     }
     return select.value;
 }
@@ -194,21 +245,28 @@ function getSelectedModel() {
 // --- Event Listeners ---
 
 // Close button
-document.getElementById('close-btn').addEventListener('click', () => {
-    window.settingsApi.closeSettings();
-});
+// Close button
+const closeBtn = document.getElementById('close-btn');
+if (closeBtn) {
+    closeBtn.addEventListener('click', () => {
+        window.settingsApi.closeSettings();
+    });
+}
 
 // Toggle API key visibility
-document.getElementById('toggle-key').addEventListener('click', () => {
-    const input = document.getElementById('api-key-input');
-    input.type = input.type === 'password' ? 'text' : 'password';
-});
+const toggleKey = document.getElementById('toggle-key');
+if (toggleKey) {
+    toggleKey.addEventListener('click', () => {
+        const input = document.getElementById('api-key-input');
+        input.type = input.type === 'password' ? 'text' : 'password';
+    });
+}
 
 async function saveApiKeyOnly() {
     const input = document.getElementById('api-key-input');
     const status = document.getElementById('api-save-status');
     const btn = document.getElementById('save-api-key');
-    const apiKey = input.value.trim();
+    const apiKey = input ? input.value.trim() : '';
 
     try {
         const baseConfig = await window.settingsApi.getSettings();
@@ -216,26 +274,31 @@ async function saveApiKeyOnly() {
         await window.settingsApi.saveSettings(nextConfig);
         currentConfig.apiKey = apiKey;
 
-        btn.textContent = 'Saved!';
-        status.textContent = 'API key saved';
+        if (btn) btn.textContent = 'Saved!';
+        if (status) status.textContent = 'API key saved';
         setTimeout(() => {
-            btn.textContent = 'Save API Key';
-            status.textContent = '';
+            if (btn) btn.textContent = 'Save API Key';
+            if (status) status.textContent = '';
         }, 1500);
     } catch (err) {
         console.error('Failed to save API key:', err);
-        status.textContent = 'Save failed';
-        setTimeout(() => { status.textContent = ''; }, 1500);
+        if (status) status.textContent = 'Save failed';
+        setTimeout(() => { if (status) status.textContent = ''; }, 1500);
     }
 }
 
-document.getElementById('save-api-key').addEventListener('click', saveApiKeyOnly);
-document.getElementById('api-key-input').addEventListener('keydown', (e) => {
-    if (e.key === 'Enter') {
-        e.preventDefault();
-        saveApiKeyOnly();
-    }
-});
+const saveApiKey = document.getElementById('save-api-key');
+if (saveApiKey) saveApiKey.addEventListener('click', saveApiKeyOnly);
+
+const apiKeyInput = document.getElementById('api-key-input');
+if (apiKeyInput) {
+    apiKeyInput.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            saveApiKeyOnly();
+        }
+    });
+}
 
 // Gemini model select
 document.getElementById('gemini-model-select').addEventListener('change', (e) => {
@@ -253,23 +316,45 @@ document.getElementById('gemini-model-custom').addEventListener('input', (e) =>
     currentConfig.geminiModel = e.target.value.trim();
 });
 
-// AI Provider toggle
-function toggleProviderOptions(provider) {
-    const geminiOptions = document.getElementById('gemini-options');
-    const ollamaOptions = document.getElementById('ollama-options');
-    
-    if (provider === 'ollama') {
-        geminiOptions.style.display = 'none';
-        ollamaOptions.style.display = 'block';
+// OpenAI model select
+document.getElementById('openai-model-select').addEventListener('change', (e) => {
+    const customRow = document.getElementById('openai-model-custom-row');
+    if (e.target.value === 'custom') {
+        customRow.style.display = 'block';
+        currentConfig.openaiModel = (document.getElementById('openai-model-custom').value || '').trim();
+    } else {
+        customRow.style.display = 'none';
+        currentConfig.openaiModel = e.target.value;
+    }
+});
+
+document.getElementById('openai-model-custom').addEventListener('input', (e) => {
+    currentConfig.openaiModel = e.target.value.trim();
+});
+
+// Anthropic model select
+document.getElementById('anthropic-model-select').addEventListener('change', (e) => {
+    const customRow = document.getElementById('anthropic-model-custom-row');
+    if (e.target.value === 'custom') {
+        customRow.style.display = 'block';
+        currentConfig.anthropicModel = (document.getElementById('anthropic-model-custom').value || '').trim();
     } else {
-        geminiOptions.style.display = 'block';
-        ollamaOptions.style.display = 'none';
+        customRow.style.display = 'none';
+        currentConfig.anthropicModel = e.target.value;
     }
+});
+
+document.getElementById('anthropic-model-custom').addEventListener('input', (e) => {
+    currentConfig.anthropicModel = e.target.value.trim();
+});
+
+// AI Provider toggle (No-op since all sections stay visible)
+function toggleProviderOptions(provider) {
+    // No-op
 }
 
 document.getElementById('ai-provider-select').addEventListener('change', (e) => {
     currentConfig.aiProvider = e.target.value;
-    toggleProviderOptions(e.target.value);
 });
 
 document.getElementById('ollama-model-input').addEventListener('input', (e) => {
@@ -277,9 +362,12 @@ document.getElementById('ollama-model-input').addEventListener('input', (e) => {
 });
 
 // AI Studio link
-document.getElementById('ai-studio-link').addEventListener('click', () => {
-    window.settingsApi.openExternal('https://aistudio.google.com/');
-});
+const aiStudioLink = document.getElementById('ai-studio-link');
+if (aiStudioLink) {
+    aiStudioLink.addEventListener('click', () => {
+        window.settingsApi.openExternal('https://aistudio.google.com/');
+    });
+}
 
 // Theme cards
 document.querySelectorAll('.theme-card').forEach(card => {
@@ -396,9 +484,34 @@ if (document.getElementById('tts-pitch')) {
 // Save
 document.getElementById('save-btn').addEventListener('click', async () => {
     currentConfig.apiKey = document.getElementById('api-key-input').value.trim();
+    
+    const anthropicInput = document.getElementById('anthropic-api-key-input');
+    if (anthropicInput) currentConfig.anthropicApiKey = anthropicInput.value.trim();
+
+    const openaiInput = document.getElementById('openai-api-key-input');
+    if (openaiInput) currentConfig.openaiApiKey = openaiInput.value.trim();
+
+    const hfInput = document.getElementById('hf-api-key');
+    if (hfInput) currentConfig.hfApiKey = hfInput.value.trim();
+
+    const ollamaHostInput = document.getElementById('ollama-host-input');
+    if (ollamaHostInput) currentConfig.ollamaHost = ollamaHostInput.value.trim();
+
     currentConfig.geminiModel = getSelectedModel();
     currentConfig.aiProvider = document.getElementById('ai-provider-select').value;
     currentConfig.ollamaModel = document.getElementById('ollama-model-input').value.trim();
+
+    currentConfig.openaiModel = getSelectedModelGeneric('openai-model-select', 'openai-model-custom', DEFAULT_CONFIG.openaiModel || 'gpt-4o');
+    currentConfig.anthropicModel = getSelectedModelGeneric('anthropic-model-select', 'anthropic-model-custom', DEFAULT_CONFIG.anthropicModel || 'claude-3-5-sonnet-latest');
+
+    const hfModelInput = document.getElementById('hf-model-name');
+    if (hfModelInput) currentConfig.hfModel = hfModelInput.value.trim();
+
+    const localApiBaseUrlInput = document.getElementById('local-api-base-url');
+    if (localApiBaseUrlInput) currentConfig.localApiBaseUrl = localApiBaseUrlInput.value.trim();
+
+    const localModelNameInput = document.getElementById('local-model-name');
+    if (localModelNameInput) currentConfig.localModelName = localModelNameInput.value.trim();
     
     const voiceReplyToggle = document.getElementById('enable-voice-reply');
     if (voiceReplyToggle) {
@@ -417,6 +530,11 @@ document.getElementById('save-btn').addEventListener('click', async () => {
         currentConfig.enableCustomWorkflows = enableWorkflowsToggle.checked;
     }
 
+    const enableAgentCollaborationToggle = document.getElementById('enable-agent-collaboration');
+    if (enableAgentCollaborationToggle) {
+        currentConfig.enableAgentCollaboration = enableAgentCollaborationToggle.checked;
+    }
+
     const showWidgetToggle = document.getElementById('show-desktop-widget');
     if (showWidgetToggle) {
         currentConfig.showDesktopWidget = showWidgetToggle.checked;
@@ -433,12 +551,100 @@ document.getElementById('save-btn').addEventListener('click', async () => {
     currentConfig.customBgEnd = document.getElementById('custom-bg-end').value;
     currentConfig.customPanelBg = document.getElementById('custom-panel-bg').value;
 
+    // Ensure mcpServers is part of the saved config
+    if (!currentConfig.mcpServers) currentConfig.mcpServers = {};
+
+    console.log('[Settings] Saving config with MCP servers:', Object.keys(currentConfig.mcpServers).length);
     await window.settingsApi.saveSettings(currentConfig);
     const btn = document.getElementById('save-btn');
     btn.textContent = '✅ Saved!';
     setTimeout(() => { btn.textContent = 'Save Settings'; }, 1500);
 });
 
+// --- MCP Management Functions ---
+function renderMcpServers() {
+    console.log('[Settings] Rendering MCP Servers UI...');
+    const list = document.getElementById('mcp-server-list');
+    if (!list) {
+        console.warn('[Settings] MCP list element not found in DOM.');
+        return;
+    }
+    list.innerHTML = '';
+
+    const servers = currentConfig.mcpServers || {};
+    const entries = Object.entries(servers);
+    console.log(`[Settings] Found ${entries.length} servers in currentConfig.`);
+
+    if (entries.length === 0) {
+        list.innerHTML = '<p class="hint" style="text-align: center; padding: 10px;">No MCP servers connected.</p>';
+        return;
+    }
+
+    for (const [name, cfg] of entries) {
+        const item = document.createElement('div');
+        item.style.cssText = 'display: flex; justify-content: space-between; align-items: center; padding: 12px; background: rgba(0,0,0,0.2); border-radius: 10px; border: 1px solid var(--border);';
+        
+        item.innerHTML = `
+            <div style="display: flex; flex-direction: column; gap: 4px;">
+                <div style="font-weight: 600; color: var(--accent); display: flex; align-items: center; gap: 6px;">
+                    <span>🌐 ${name}</span>
+                </div>
+                <div style="font-size: 0.75rem; opacity: 0.7; font-family: monospace;">${cfg.command} ${cfg.args.join(' ')}</div>
+            </div>
+            <button class="btn-danger" style="padding: 6px 12px; font-size: 0.8rem;" onclick="removeMcpServer('${name}')">Remove</button>
+        `;
+        list.appendChild(item);
+    }
+}
+
+window.removeMcpServer = function(name) {
+    if (confirm(`Remove MCP server "${name}"?`)) {
+        delete currentConfig.mcpServers[name];
+        renderMcpServers();
+    }
+};
+
+document.getElementById('btn-add-mcp').addEventListener('click', () => {
+    const nameInput = document.getElementById('mcp-new-name');
+    const cmdInput = document.getElementById('mcp-new-command');
+    const argsInput = document.getElementById('mcp-new-args');
+    const envInput = document.getElementById('mcp-new-env');
+
+    const name = nameInput.value.trim();
+    const command = cmdInput.value.trim();
+    const argsStr = argsInput.value.trim();
+    const envStr = envInput.value.trim();
+
+    if (!name || !command) {
+        alert('Name and Command are required!');
+        return;
+    }
+
+    // Basic args split (by space, but respecting some quotes if possible - simple for now)
+    const args = argsStr ? argsStr.split(/\s+/) : [];
+    
+    let env = {};
+    if (envStr) {
+        try {
+            env = JSON.parse(envStr);
+        } catch (e) {
+            alert('Invalid JSON in Environment Variables field!');
+            return;
+        }
+    }
+
+    if (!currentConfig.mcpServers) currentConfig.mcpServers = {};
+    currentConfig.mcpServers[name] = { command, args, env };
+
+    // Clear inputs
+    nameInput.value = '';
+    cmdInput.value = '';
+    argsInput.value = '';
+    envInput.value = '';
+
+    renderMcpServers();
+});
+
 // Custom Workflows functionality
 const openWorkflowsBtn = document.getElementById('open-workflows-btn');
 const reloadWorkflowsBtn = document.getElementById('reload-workflows-btn');
@@ -508,6 +714,11 @@ document.querySelectorAll('.tab-btn').forEach(btn => {
         btn.classList.add('active');
         const pane = document.getElementById(target);
         if (pane) pane.classList.add('active');
+
+        // Re-render MCP list if switching to plugins tab
+        if (target === 'sect-plugins') {
+            renderMcpServers();
+        }
     });
 });
 

package/tests/agent_orchestrator.test.js

@@ -0,0 +1,41 @@
+/**
+ * Tests: agent_orchestrator.js
+ */
+
+const orchestrator = require('../src/AI_Brain/agent_orchestrator');
+
+describe('Agent Orchestrator', () => {
+    beforeEach(() => {
+        orchestrator.resetAgent();
+    });
+
+    test('starts with general agent', () => {
+        const agent = orchestrator.getCurrentAgent();
+        expect(agent.name).toBe('Mint Default');
+    });
+
+    test('can switch to coder agent', () => {
+        orchestrator.setAgent('coder');
+        const agent = orchestrator.getCurrentAgent();
+        expect(agent.name).toBe('Mint Coder');
+    });
+
+    test('can switch to researcher agent', () => {
+        orchestrator.setAgent('researcher');
+        const agent = orchestrator.getCurrentAgent();
+        expect(agent.name).toBe('Mint Researcher');
+    });
+
+    test('falls back to general for invalid agent', () => {
+        orchestrator.setAgent('nonexistent');
+        const agent = orchestrator.getCurrentAgent();
+        expect(agent.name).toBe('Mint Default');
+    });
+
+    test('lists available agents', () => {
+        const agents = orchestrator.listAgents();
+        expect(agents).toContain('general');
+        expect(agents).toContain('coder');
+        expect(agents).toContain('researcher');
+    });
+});

package/tests/config_manager.test.js

@@ -0,0 +1,141 @@
+/**
+ * Tests: config_manager.js
+ * Tests readConfig, writeConfig, and getAvailableProviders.
+ *
+ * Isolation strategy: spy on os.homedir() BEFORE requiring config_manager
+ * so CONFIG_DIR and CONFIG_PATH point to a temp directory, never touching
+ * the real ~/.config/mint/mint-config.json.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+let tempDir;
+
+beforeEach(() => {
+    // 1. Reset module registry so config_manager re-initialises fresh each test
+    jest.resetModules();
+
+    // 2. Create an isolated temp dir for this test
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-cfg-test-'));
+
+    // 3. Mock os.homedir() BEFORE requiring config_manager.
+    //    config_manager computes CONFIG_DIR = os.homedir() + '/.config/mint'
+    //    at load time, so the spy must be active when the module first loads.
+    jest.spyOn(os, 'homedir').mockReturnValue(tempDir);
+});
+
+afterEach(() => {
+    jest.restoreAllMocks();
+    jest.resetModules();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+});
+
+// Helper — always gets a fresh, isolated instance of config_manager
+function getModule() {
+    return require('../src/System/config_manager');
+}
+
+// ── readConfig ─────────────────────────────────────────────────────────────
+
+describe('config_manager — readConfig', () => {
+    test('returns DEFAULT_CONFIG when no config file exists', () => {
+        const { readConfig } = getModule();
+        const config = readConfig();
+        expect(config).toHaveProperty('geminiModel', 'gemini-2.5-flash');
+        expect(config).toHaveProperty('aiProvider', 'gemini');
+        expect(config).toHaveProperty('language', 'th-TH');
+    });
+
+    test('merges saved values with defaults (saved value wins)', () => {
+        const { readConfig, writeConfig } = getModule();
+        writeConfig({ geminiModel: 'gemini-2.0-pro' });
+        const config = readConfig();
+        expect(config.geminiModel).toBe('gemini-2.0-pro');
+        // Default fields still present
+        expect(config.aiProvider).toBe('gemini');
+        expect(config.language).toBe('th-TH');
+    });
+
+    test('missing keys in saved file are filled by defaults', () => {
+        const { readConfig, writeConfig } = getModule();
+        // Write a partial config (no 'ollamaModel' key)
+        writeConfig({ geminiModel: 'my-model' });
+        const config = readConfig();
+        expect(config.ollamaModel).toBe('llama3:latest'); // default
+    });
+});
+
+// ── writeConfig ────────────────────────────────────────────────────────────
+
+describe('config_manager — writeConfig', () => {
+    test('returns { success: true } on valid write', () => {
+        const { writeConfig } = getModule();
+        const result = writeConfig({ testKey: 'testValue' });
+        expect(result).toEqual({ success: true });
+    });
+
+    test('written JSON is readable back correctly', () => {
+        const { readConfig, writeConfig } = getModule();
+        writeConfig({ geminiModel: 'custom-model-test' });
+        const config = readConfig();
+        expect(config.geminiModel).toBe('custom-model-test');
+    });
+
+    test('config file is actually created on disk', () => {
+        const { writeConfig, CONFIG_PATH } = getModule();
+        writeConfig({ geminiModel: 'test' });
+        expect(fs.existsSync(CONFIG_PATH)).toBe(true);
+    });
+});
+
+// ── getAvailableProviders ──────────────────────────────────────────────────
+
+describe('config_manager — getAvailableProviders', () => {
+    test('always includes ollama (local, no key needed)', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({})).toContain('ollama');
+    });
+
+    test('includes gemini when apiKey is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({ apiKey: 'test-key' })).toContain('gemini');
+    });
+
+    test('includes anthropic when anthropicApiKey is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({ anthropicApiKey: 'ant-key' })).toContain('anthropic');
+    });
+
+    test('includes openai when openaiApiKey is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({ openaiApiKey: 'oai-key' })).toContain('openai');
+    });
+
+    test('includes huggingface when hfApiKey is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(getAvailableProviders({ hfApiKey: 'hf-key' })).toContain('huggingface');
+    });
+
+    test('includes local_openai when localApiBaseUrl is set', () => {
+        const { getAvailableProviders } = getModule();
+        expect(
+            getAvailableProviders({ localApiBaseUrl: 'http://localhost:1234/v1' })
+        ).toContain('local_openai');
+    });
+
+    test('does NOT include gemini when no key', () => {
+        const { getAvailableProviders } = getModule();
+        const savedEnv = process.env.GEMINI_API_KEY;
+        delete process.env.GEMINI_API_KEY;
+        const providers = getAvailableProviders({ apiKey: '' });
+        expect(providers).not.toContain('gemini');
+        if (savedEnv) process.env.GEMINI_API_KEY = savedEnv;
+    });
+
+    test('returns array type', () => {
+        const { getAvailableProviders } = getModule();
+        expect(Array.isArray(getAvailableProviders({}))).toBe(true);
+    });
+});