vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1835

package/src/commands/auto-direct/iteration-runner.js

@@ -0,0 +1,485 @@
+/**
+ * Iteration Runner - Main Iteration Workflow
+ *
+ * Extracted from iteration-handlers.js for constitutional compliance (<555 lines per file)
+ * Contains the main runIteration function that orchestrates the PREPARE, ACT, CLEAN UP, VERIFY, DONE phases
+ */
+
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const { DirectLLMManager, t } = vibecodingmachineCore;
+
+// Import modular functions
+const { getLogTimestamp } = require('./utils');
+const { moveRequirementToVerify } = require('./requirement-manager');
+const { parseSearchReplaceBlocks, applyFileChange } = require('./code-processor');
+const { findRelevantFiles, readFileSnippets } = require('./file-scanner');
+const { printStatusCard } = require('./status-display');
+
+// Import runIdeFallbackIteration from iteration-handlers (to avoid circular dependency)
+let runIdeFallbackIteration = null;
+
+// Shared variables set by parent module
+let sharedProviderManager = null;
+let sharedHealthTracker = null;
+
+/**
+ * Initialize module with shared instances and function references
+ */
+function initialize(deps) {
+  sharedProviderManager = deps.providerManager;
+  sharedHealthTracker = deps.healthTracker;
+  runIdeFallbackIteration = deps.runIdeFallbackIteration;
+}
+
+/**
+ * Run one iteration of autonomous mode with full workflow
+ * @param {Object} requirement - Requirement object
+ * @param {Object} providerConfig - Provider configuration
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<{success: boolean, changes?: Array, error?: string}>}
+ */
+async function runIteration(requirement, providerConfig, repoPath) {
+  const startTime = Date.now();
+  const providerManager = sharedProviderManager; // Use shared instance to persist rate limit state
+  const llm = new DirectLLMManager(sharedProviderManager); // Pass shared instance
+
+  if (providerConfig.type === 'ide') {
+    return runIdeFallbackIteration(requirement, providerConfig, repoPath, providerManager, llm, startTime);
+  }
+
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  // PREPARE PHASE - SEARCH AND READ ACTUAL FILES
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  printStatusCard(requirement.text, 'PREPARE', 'active');
+
+  console.log(chalk.bold.white('=� REQUIREMENT:'));
+  console.log(chalk.cyan(`   ${requirement.text}\n`));
+  console.log(chalk.gray(t('auto.direct.summary.provider')), chalk.white(providerConfig.displayName));
+  console.log(chalk.gray(t('auto.repository')), chalk.white(repoPath));
+  console.log();
+
+  console.log(chalk.cyan(`= ${t('auto.direct.files.searching')}...\n`));
+  const relevantFiles = await findRelevantFiles(requirement.text, repoPath);
+
+  if (relevantFiles.length > 0) {
+    console.log(chalk.white(`${t('auto.direct.files.found', { count: relevantFiles.length })}:`));
+    relevantFiles.forEach((file, i) => {
+      console.log(chalk.gray(`  ${i + 1}. ${file}`));
+    });
+    console.log();
+  }
+
+  console.log(chalk.cyan('=� Reading file context...\n'));
+  const fileSnippets = await readFileSnippets(relevantFiles, repoPath, requirement.text);
+
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  // ACT PHASE - GET STRUCTURED CHANGES FROM LLM
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  printStatusCard(requirement.text, 'ACT', 'active');
+
+  console.log(chalk.cyan(` ${getLogTimestamp()} - > Asking LLM for implementation...\n`));
+  console.log(chalk.gray(' '.repeat(80)));
+  console.log(chalk.yellow('=� LLM Response (streaming):'));
+  console.log(chalk.gray(' '.repeat(80)));
+
+  // Build context with actual file snippets (use relative paths)
+  let contextSection = '';
+  if (fileSnippets.length > 0) {
+    contextSection = '\n\nCURRENT CODE CONTEXT:\n';
+    fileSnippets.forEach(({ file, snippet, startLine }) => {
+      // Convert to relative path if absolute
+      let displayPath = file;
+      if (path.isAbsolute(file)) {
+        displayPath = path.relative(repoPath, file);
+      }
+      contextSection += `\n--- ${displayPath} (around line ${startLine}) ---\n${snippet}\n`;
+    });
+  }
+
+  // Check if requirement involves removing menu items or UI elements
+  const isRemovalRequirement = /remove|delete|eliminate/i.test(requirement.text) &&
+    (/menu|item|option|setting|button|ui|element/i.test(requirement.text));
+
+  let removalInstructions = '';
+  if (isRemovalRequirement) {
+    removalInstructions = `
+
+� CRITICAL: THIS IS A REMOVAL REQUIREMENT �
+
+When removing menu items, UI elements, or settings, you MUST:
+
+1. **FIND ALL OCCURRENCES**: Search the CURRENT CODE CONTEXT for:
+   - The exact text/identifier mentioned in the requirement
+   - Variations (e.g., "Restart CLI", "restart CLI", "restartCLI", "setting:restart-cli")
+   - Both display code (where it's shown) AND handler code (where it's processed)
+
+2. **REMOVE ALL CODE, NOT JUST TOGGLE**:
+   - DELETE the code that displays/creates the menu item (e.g., items.push() calls)
+   - DELETE the handler code that processes the action (e.g., case 'setting:restart-cli': blocks)
+   - DELETE any configuration/state code related to the item (e.g., const restartCLI = ...)
+   - DELETE any variable declarations or references to the item
+
+3. **MULTIPLE FILES MAY BE AFFECTED**:
+   - If you find references in multiple files, you MUST provide multiple FILE/SEARCH/REPLACE blocks
+   - Each file needs its own FILE/SEARCH/REPLACE block
+   - Remove ALL occurrences across ALL files shown in the context
+
+4. **VERIFICATION**:
+   - After removal, the code should compile/run without errors
+   - The removed item should not appear anywhere in the codebase
+   - All related handlers and configuration should be removed
+
+EXAMPLE for removing "Restart CLI after each completed requirement":
+- Remove: items.push({ type: 'setting', name: \`...Restart CLI...\`, value: 'setting:restart-cli' })
+- Remove: case 'setting:restart-cli': { ... } handler block
+- Remove: const restartCLI = ... variable declaration
+- Remove: Any other references to restartCLI or 'setting:restart-cli'
+
+`;
+  }
+
+  const prompt = `You are implementing a code change. Your task is to provide a SEARCH/REPLACE block that will modify the code.
+
+REQUIREMENT TO IMPLEMENT:
+${requirement.text}
+${removalInstructions}
+${contextSection}
+
+YOUR TASK:
+1. Read the CURRENT CODE CONTEXT carefully
+2. Find the EXACT location where changes are needed
+3. COPY AT LEAST 10 LINES EXACTLY as they appear (including indentation, spacing, comments)
+4. Show what the code should look like after your changes
+${isRemovalRequirement ? '5. **REMOVE ALL CODE** related to the item - do NOT comment it out, DELETE it completely' : ''}
+
+OUTPUT FORMAT:
+
+For modifying existing files:
+FILE: <exact path from the "---" line - must be relative to repo root>
+SEARCH: \`\`\`javascript
+<COPY 10+ lines EXACTLY - preserve indentation, spacing, comments>
+\`\`\`
+REPLACE: \`\`\`javascript
+<SAME lines but with necessary modifications>
+\`\`\`
+
+For creating new files:
+CREATE: <relative path to new file>
+CONTENT: \`\`\`javascript
+<full content of new file>
+\`\`\`
+
+CRITICAL RULES - READ CAREFULLY:
+1. If the file does NOT exist, use CREATE: format to create it
+2. If the file DOES exist and you need to modify it, use FILE:/SEARCH:/REPLACE: format
+3. For FILE: blocks, SEARCH block must be COPIED CHARACTER-BY-CHARACTER from CURRENT CODE CONTEXT above
+4. Use the EXACT code as it appears NOW - do NOT use old/outdated code from memory
+5. Include ALL property values EXACTLY as shown (e.g., if context shows 'type: "info"', use 'type: "info"', NOT 'type: "setting"')
+6. Include indentation EXACTLY as shown (count the spaces!)
+7. For modifications, include AT LEAST 20-30 LINES of context:
+   - Start 10-15 lines BEFORE the code you need to change
+   - End 10-15 lines AFTER the code you need to change
+   - MORE context is BETTER than less - include extra lines if unsure
+8. Do NOT paraphrase or rewrite - COPY EXACTLY from CURRENT CODE CONTEXT
+9. FILE path must match exactly what's after "---" in CURRENT CODE CONTEXT (DO NOT include the "---" itself)
+10. All paths must be RELATIVE to repo root (e.g., "specs/005-beta-pricing/tasks.md" NOT "/Users/.../tasks.md")
+11. Output ONLY the FILE/SEARCH/REPLACE or CREATE/CONTENT blocks
+12. NO explanations, NO markdown outside the blocks, NO additional text
+13. If you cannot find the exact code to modify, output: ERROR: CANNOT LOCATE CODE IN CONTEXT
+14. IMPORTANT: Include ALL intermediate code between the before/after context - do NOT skip lines
+15. DOUBLE-CHECK: Compare your SEARCH block line-by-line with CURRENT CODE CONTEXT to ensure they match
+
+EXAMPLE (notice EXACT copying of indentation and spacing):
+
+FILE: packages/cli/src/utils/interactive.js
+SEARCH: \`\`\`javascript
+// Add warning if no TODO requirements
+if (counts.todoCount === 0) {
+  requirementsText += \` \${chalk.red('� No requirements to work on')}\`;
+      }
+    } else {
+      requirementsText += \`\${chalk.yellow('0 TODO')}, \${chalk.cyan('0 TO VERIFY')}, \${chalk.green('0 VERIFIED')} \${chalk.red('� No requirements')}\`;
+}
+\`\`\`
+REPLACE: \`\`\`javascript
+// Add warning if no TODO requirements
+if (counts.todoCount === 0) {
+  requirementsText += \` \${chalk.red('� No requirements')}\`;
+      }
+    } else {
+      requirementsText += \`\${chalk.yellow('0 TODO')}, \${chalk.cyan('0 TO VERIFY')}, \${chalk.green('0 VERIFIED')} \${chalk.red('� No requirements')}\`;
+}
+\`\`\`
+
+CREATE EXAMPLE (for new files):
+
+CREATE: packages/web/src/utils/paypal-config.js
+CONTENT: \`\`\`javascript
+/**
+ * PayPal Configuration Utility
+ */
+
+export const getPayPalClientId = () => {
+  return import.meta.env.VITE_PAYPAL_CLIENT_ID;
+};
+
+export const getPayPalEnvironment = () => {
+  return import.meta.env.VITE_PAYPAL_ENVIRONMENT || 'sandbox';
+};
+\`\`\`
+
+Now implement the requirement. Remember: For modifications, COPY THE SEARCH BLOCK EXACTLY! For new files, use CREATE: format.`;
+
+  let fullResponse = '';
+  let chunkCount = 0;
+  let totalChars = 0;
+
+  // Show spinner while waiting for first chunk
+  const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let spinnerIndex = 0;
+  let spinnerInterval = null;
+  let receivedFirstChunk = false;
+
+  const startSpinner = () => {
+    process.stdout.write(chalk.cyan('� Waiting for response'));
+    spinnerInterval = setInterval(() => {
+      process.stdout.write(`\r${chalk.cyan('� Waiting for response')} ${chalk.yellow(spinnerFrames[spinnerIndex])}`);
+      spinnerIndex = (spinnerIndex + 1) % spinnerFrames.length;
+    }, 100);
+  };
+
+  const stopSpinner = () => {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval);
+      spinnerInterval = null;
+      process.stdout.write('\r\x1b[K'); // Clear the line
+    }
+  };
+
+  startSpinner();
+
+  const result = await llm.call(providerConfig, prompt, {
+    temperature: 0.1,
+    maxTokens: 4096,
+    onChunk: (chunk) => {
+      chunkCount++;
+      totalChars += chunk.length;
+      // Show first chunk arrival to confirm streaming started
+      if (chunkCount === 1) {
+        stopSpinner();
+        receivedFirstChunk = true;
+        process.stdout.write(chalk.green(' Streaming started...\n'));
+      }
+      // Use white text for better visibility instead of gray
+      process.stdout.write(chalk.white(chunk));
+      fullResponse += chunk;
+    },
+    onComplete: () => {
+      stopSpinner();
+      if (chunkCount > 0) {
+        console.log(chalk.green(`\n Received ${totalChars} characters in ${chunkCount} chunks`));
+      } else {
+        console.log(chalk.yellow('\n�  No streaming response received (using complete response)'));
+      }
+      console.log(chalk.gray(' '.repeat(80)));
+      console.log();
+    },
+    onError: (error) => {
+      stopSpinner();
+      console.error(chalk.red(`\n Error: ${error}`));
+    }
+  });
+
+  // Ensure spinner is stopped even if callbacks didn't fire
+  stopSpinner();
+
+  if (!result.success) {
+    const combinedError = [result.error, fullResponse].filter(Boolean).join('\n').trim() || 'Unknown error';
+    console.log(chalk.red(`\n LLM call failed: ${combinedError}`));
+    // CRITICAL: Mark provider as rate-limited for ANY error so acquireProviderConfig() will skip it
+    providerManager.markRateLimited(providerConfig.provider, providerConfig.model, combinedError);
+
+    // Track health metrics for failed direct providers
+    const providerType = providerConfig.provider;
+    const duration = Date.now() - startTime;
+    try {
+      // Detect quota/rate limit errors vs other failures
+      const quotaPattern = /(quota|rate.?limit|usage.?limit|spending.?cap|allowance|exceeded|overloaded)/i;
+      const isQuotaError = quotaPattern.test(combinedError);
+
+      if (isQuotaError) {
+        await sharedHealthTracker.recordQuota(providerType, combinedError, {
+          requirementId: requirement.id || requirement.text.substring(0, 50),
+        });
+      } else {
+        await sharedHealthTracker.recordFailure(providerType, combinedError, {
+          timeoutUsed: duration,
+          requirementId: requirement.id || requirement.text.substring(0, 50),
+        });
+      }
+    } catch (healthError) {
+      // Don't fail the iteration if health tracking fails
+      console.log(chalk.gray(`�  Health tracking error: ${healthError.message}`));
+    }
+
+    return { success: false, error: combinedError };
+  }
+
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  // CLEAN UP PHASE - APPLY CHANGES TO ACTUAL FILES
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  printStatusCard(requirement.text, 'CLEAN UP', 'active');
+
+  console.log(chalk.cyan('>� Parsing and applying changes...\n'));
+
+  // Check if LLM said it cannot locate code
+  if (fullResponse.includes('ERROR: CANNOT LOCATE CODE') || fullResponse.includes('CANNOT LOCATE CODE')) {
+    console.log(chalk.red('\n LLM could not locate the code to modify'));
+    console.log(chalk.yellow('The code context provided may not contain the relevant section\n'));
+    return { success: false, error: 'LLM could not locate code in context', changes: [] };
+  }
+
+  const changes = parseSearchReplaceBlocks(fullResponse);
+
+  if (changes.length === 0) {
+    if (fullResponse.includes('NO CHANGES NEEDED')) {
+      console.log(chalk.yellow('�  LLM determined no code changes needed\n'));
+      return { success: false, error: 'No changes needed', changes: [] };
+    } else {
+      console.log(chalk.yellow('�  Could not parse any search/replace blocks from LLM response\n'));
+      console.log(chalk.gray('This might be a documentation-only requirement or LLM formatting issue\n'));
+      return { success: false, error: 'No search/replace blocks found', changes: [] };
+    }
+  } else {
+    console.log(chalk.white(`Applying ${changes.length} change(s):\n`));
+
+    let appliedCount = 0;
+    let failedCount = 0;
+
+    for (let i = 0; i < changes.length; i++) {
+      const change = changes[i];
+      console.log(chalk.cyan(`  ${i + 1}. ${change.file}...`));
+
+      const applyResult = await applyFileChange(change, repoPath);
+
+      if (applyResult.success) {
+        const methodInfo = applyResult.method === 'fuzzy'
+          ? ` (fuzzy match at line ${applyResult.matchedAt})`
+          : '';
+        console.log(chalk.green(`      Applied successfully${methodInfo}`));
+        appliedCount++;
+      } else {
+        console.log(chalk.red(`      Failed: ${applyResult.error}`));
+        failedCount++;
+      }
+    }
+
+    console.log();
+    console.log(chalk.white(`Applied: ${chalk.green(appliedCount)}, Failed: ${chalk.red(failedCount)}`));
+    console.log();
+
+    // CRITICAL: Fail if no changes were applied successfully
+    if (appliedCount === 0 && failedCount > 0) {
+      console.log(chalk.bold.red('\nL ITERATION FAILED\n'));
+      console.log(chalk.red('No changes were successfully applied'));
+      console.log(chalk.yellow('Common causes:'));
+      console.log(chalk.gray('  - LLM provided incorrect search text'));
+      console.log(chalk.gray('  - Code has changed since context was provided'));
+      console.log(chalk.gray('  - File path is incorrect'));
+      console.log();
+      console.log(chalk.cyan('=� Tip: Check the search block matches the actual code in the file'));
+      console.log();
+      return { success: false, error: 'No changes applied', changes: [] };
+    }
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  // VERIFY PHASE - CONFIRM CHANGES WERE APPLIED
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  printStatusCard(requirement.text, 'VERIFY', 'active');
+
+  console.log(chalk.cyan(' Verifying changes...\n'));
+
+  if (changes.length > 0) {
+    console.log(chalk.white('Modified files:'));
+    for (const change of changes) {
+      const fullPath = path.join(repoPath, change.file);
+      if (await fs.pathExists(fullPath)) {
+        const content = await fs.readFile(fullPath, 'utf8');
+
+        // Handle both create and modify types
+        let hasChange = false;
+        if (change.type === 'create') {
+          hasChange = change.content && content.includes(change.content.trim());
+        } else {
+          hasChange = change.replace && content.includes(change.replace.trim());
+        }
+
+        if (hasChange) {
+          console.log(chalk.green(`   ${change.file}`));
+        } else {
+          console.log(chalk.yellow(`  �  ${change.file} (change may not have applied)`));
+        }
+      }
+    }
+    console.log();
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  // DONE PHASE
+  // PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+  printStatusCard(requirement.text, 'DONE', 'active');
+
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+
+  console.log(chalk.bold.green(` ${t('auto.direct.requirement.completed')}\n`));
+  console.log(chalk.white(`${t('auto.direct.requirement.title')}`), chalk.cyan(requirement.text));
+  console.log(chalk.white(t('auto.direct.summary.files.modified')), chalk.cyan(changes.length));
+  console.log(chalk.white(t('auto.direct.summary.status')), chalk.green(t('auto.direct.summary.moving.to.verify')));
+  console.log(chalk.white(t('auto.direct.summary.time')), chalk.gray(`${elapsed}s`));
+  console.log();
+
+  // Move requirement to TO VERIFY section
+  const moved = await moveRequirementToVerify(repoPath, requirement.text);
+  if (moved) {
+    console.log(chalk.green(` ${t('auto.direct.status.verification.pending')}`));
+  } else {
+    console.log(chalk.yellow('�  Could not automatically move requirement'));
+  }
+
+  // Record performance metric
+  const duration = Date.now() - startTime;
+  providerManager.recordPerformance(providerConfig.provider, providerConfig.model, duration);
+
+  // Track health metrics for direct providers (IDE providers tracked in runIdeFallbackIteration)
+  const providerType = providerConfig.provider;
+  try {
+    await sharedHealthTracker.recordSuccess(providerType, duration, {
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+      continuationPromptsDetected: 0,
+    });
+  } catch (healthError) {
+    // Don't fail the iteration if health tracking fails
+    console.log(chalk.gray(`�  Health tracking error: ${healthError.message}`));
+  }
+
+  console.log();
+  console.log(chalk.gray(' '.repeat(80)));
+  console.log();
+
+  return { success: true, changes };
+}
+
+module.exports = {
+  initialize,
+  runIteration
+};

package/src/commands/auto-direct/provider-config.js

@@ -3,7 +3,7 @@
  * Extracted from auto-direct.js to reduce file size
  */
 
-const { getAutoConfig } = require('../../../utils/config');
+const { getAutoConfig } = require('../../utils/config');
 const { getProviderPreferences, getProviderDefinition, saveProviderPreferences } = require('../../utils/provider-registry');
 const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
 const { checkAntigravityRateLimit, handleAntigravityRateLimit } = require('../../utils/antigravity-js-handler');
@@ -13,6 +13,22 @@ const { checkClineRateLimit, handleClineRateLimit } = require('../../utils/cline
 // CRITICAL: Shared ProviderManager instance to track rate limits across all function calls
 const sharedProviderManager = new ProviderManager();
 
+/**
+ * Normalize config.providers to a {providerName: configObj} map.
+ * Handles both array format [{provider, model, ...}] and object format {name: {...}}.
+ */
+function normalizeProvidersMap(rawProviders) {
+  if (!rawProviders) return {};
+  if (Array.isArray(rawProviders)) {
+    const map = {};
+    for (const entry of rawProviders) {
+      if (entry && entry.provider) map[entry.provider] = entry;
+    }
+    return map;
+  }
+  return rawProviders;
+}
+
 /**
  * Get all available provider configurations
  */
@@ -23,8 +39,10 @@ async function getAllAvailableProviders() {
   const providers = [];
   const skipped = [];
 
+  const providersMap = normalizeProvidersMap(config.providers);
+
   // Check each provider in config
-  for (const [providerName, providerConfig] of Object.entries(config.providers || {})) {
+  for (const [providerName, providerConfig] of Object.entries(providersMap)) {
     // Skip if provider is disabled in preferences
     if (prefs.disabled?.includes(providerName)) {
       skipped.push(providerName);
@@ -130,8 +148,21 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
   // If a specific provider is forced, bypass normal selection
   if (forcedProvider) {
     const { providers } = await getAllAvailableProviders();
-    const provider = providers.find(p => p.name === forcedProvider);
-    
+    let provider = providers.find(p => p.name === forcedProvider);
+
+    // Fall back to registry definition for credential-free providers (e.g. claude-code CLI)
+    if (!provider) {
+      const definition = getProviderDefinition(forcedProvider);
+      if (definition && !definition.credentials?.length) {
+        provider = {
+          name: forcedProvider,
+          displayName: definition.displayName || forcedProvider,
+          config: {},
+          definition
+        };
+      }
+    }
+
     if (!provider) {
       throw new Error(`Forced provider "${forcedProvider}" not available`);
     }
@@ -146,16 +177,16 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
   }
 
   const config = await getProviderConfig(excludeProvider);
-  
+
   // Model selection logic
   let selectedModel = config.config.model;
-  
+
   // Exclude specific model if requested
   if (excludeModel && selectedModel === excludeModel) {
     // Try alternative models
     const alternativeModels = config.definition.models || [];
     const availableModel = alternativeModels.find(m => m !== excludeModel && m !== selectedModel);
-    
+
     if (availableModel) {
       selectedModel = availableModel;
     } else {