feat: Add explicit model provider configuration support

- Extended configuration system to support explicit model provider selection
- Added environment variables for specifying providers per mode
- Updated config parsing to handle mode-specific and global provider settings
- Enhanced PatchClient to dynamically select model providers based on configuration
- Updated .env.example and README with new provider configuration options
- Implemented flexible provider detection logic with fallback mechanisms

Author: stevengonsalvez

.env.example

@@ -32,6 +32,18 @@ OPENROUTER_API_KEY=
 OPENAI_API_KEYS=key1,key2,key3
 ANTHROPIC_API_KEYS=key1,key2,key3
 
+# Model provider configuration
+# Explicitly specify which provider to use (openai, anthropic, openrouter)
+# This overrides automatic detection based on model name
+PATCH_MODEL_PROVIDER=openai
+
+# Mode-specific model providers (optional)
+PATCH_MODEL_PROVIDER_ARCHITECT=anthropic
+PATCH_MODEL_PROVIDER_PATCHER=openai
+PATCH_MODEL_PROVIDER_HYBRID_SECURITY=anthropic
+PATCH_MODEL_PROVIDER_HYBRID_PERFORMANCE=openai
+PATCH_MODEL_PROVIDER_HYBRID_TYPESCRIPT=openai
+
 # Label that triggers patchmycode to fix an issue
 PATCH_TRIGGER_LABEL=fix:auto
 # Additional labels that can trigger fixes (comma-separated)

README.md

@@ -81,7 +81,13 @@ Create a `.patchmycode/config.json` file in your repository to customize behavio
   },
   "modelMap": {
     "architect": "claude-3-7-sonnet",
-    "patcher": "gpt-4o"
+    "patcher": "gpt-4o",
+    "hybrid:security": "claude-3-opus-20240229"
+  },
+  "providerMap": {
+    "architect": "anthropic",
+    "patcher": "openai",
+    "hybrid:security": "anthropic"
   }
 }
 ```
@@ -176,6 +182,14 @@ You can set models globally or per mode:
   - `PATCH_MODEL_HYBRID_PERFORMANCE`: Model for performance hybrid mode
   - `PATCH_MODEL_HYBRID_TYPESCRIPT`: Model for TypeScript hybrid mode
 
+- **Model provider configuration**:
+  - `PATCH_MODEL_PROVIDER`: Explicitly specify which provider to use (openai, anthropic, openrouter)
+  - `PATCH_MODEL_PROVIDER_ARCHITECT`: Provider for architect mode
+  - `PATCH_MODEL_PROVIDER_PATCHER`: Provider for patcher mode
+  - `PATCH_MODEL_PROVIDER_HYBRID_SECURITY`: Provider for security hybrid mode
+  - `PATCH_MODEL_PROVIDER_HYBRID_PERFORMANCE`: Provider for performance hybrid mode
+  - `PATCH_MODEL_PROVIDER_HYBRID_TYPESCRIPT`: Provider for TypeScript hybrid mode
+
 - **Model-specific arguments**:
   - `PATCH_EXTRA_ARGS`: Global extra arguments for Aider
   - `PATCH_EXTRA_ARGS_ARCHITECT`: Arguments specific to architect mode

example-aider-config.json

@@ -28,6 +28,14 @@
     "hybrid": "claude-3-opus",
     "default": "gpt-4o"
   },
+  "providerMap": {
+    "architect": "anthropic",
+    "patcher": "openai",
+    "hybrid:security": "anthropic",
+    "hybrid:performance": "openai",
+    "hybrid:typescript-migration": "openrouter",
+    "default": "openai"
+  },
   "systemPrompts": {
     "architect": "You are an expert software architect with deep knowledge of design patterns and software engineering principles. Focus on high-level design, refactoring, and code organization. Think about maintainability, extensibility, and adherence to SOLID principles. Prefer clear, modular designs over clever tricks.",
     "patcher": "You are an expert code editor with a keen eye for bugs and implementation details. Focus on fixing specific issues with minimal changes. Prioritize correctness, security, and performance in that order. Maintain the existing code style and patterns unless there's a compelling reason to change them.",

src/config.ts

@@ -18,10 +18,12 @@ export interface PatchBotConfig {
   // LLM configuration
   model?: string;                // Default LLM model to use
   extraArgs?: string[];          // Default additional arguments to pass to the LLM
+  modelProvider?: string;        // Default model provider to use (openai, anthropic, openrouter)
 
   // Mode-specific LLM configuration
   modeModels?: Record<string, string>; // Mapping of modes to specific models
   modeExtraArgs?: Record<string, string[]>; // Mapping of modes to specific extra args
+  modeProviders?: Record<string, string>; // Mapping of modes to specific providers
 
   // API Keys configuration
   openaiKeys?: string[];         // OpenAI API keys for load balancing
@@ -147,6 +149,48 @@ const getModeExtraArgs = (): Record<string, string[]> => {
   return modeExtraArgs;
 };
 
+// Create a map for mode-specific providers
+const getModeProviders = (): Record<string, string> => {
+  const modeProviders: Record<string, string> = {};
+  
+  // Check for default provider
+  const defaultProvider = process.env.PATCH_MODEL_PROVIDER;
+  if (defaultProvider) {
+    // This will be the fallback for modes without specific providers
+    modeProviders['default'] = defaultProvider.toLowerCase();
+  }
+  
+  // Check for architect mode provider
+  const architectProvider = process.env.PATCH_MODEL_PROVIDER_ARCHITECT;
+  if (architectProvider) {
+    modeProviders['architect'] = architectProvider.toLowerCase();
+  }
+  
+  // Check for patcher mode provider
+  const patcherProvider = process.env.PATCH_MODEL_PROVIDER_PATCHER;
+  if (patcherProvider) {
+    modeProviders['patcher'] = patcherProvider.toLowerCase();
+  }
+  
+  // Check for hybrid mode providers
+  const securityProvider = process.env.PATCH_MODEL_PROVIDER_HYBRID_SECURITY;
+  if (securityProvider) {
+    modeProviders['hybrid:security'] = securityProvider.toLowerCase();
+  }
+  
+  const performanceProvider = process.env.PATCH_MODEL_PROVIDER_HYBRID_PERFORMANCE;
+  if (performanceProvider) {
+    modeProviders['hybrid:performance'] = performanceProvider.toLowerCase();
+  }
+  
+  const typescriptProvider = process.env.PATCH_MODEL_PROVIDER_HYBRID_TYPESCRIPT;
+  if (typescriptProvider) {
+    modeProviders['hybrid:typescript'] = typescriptProvider.toLowerCase();
+  }
+  
+  return modeProviders;
+};
+
 // Get multiple API keys
 const getApiKeys = (): {
   openaiKeys: string[];
@@ -209,10 +253,12 @@ const config: PatchBotConfig = {
   // LLM configuration
   model: getEnv('PATCH_MODEL', 'gpt-4-turbo'),
   extraArgs: getArrayEnv('PATCH_EXTRA_ARGS'),
+  modelProvider: getEnv('PATCH_MODEL_PROVIDER', ''),
 
   // Mode-specific LLM configuration
   modeModels: getModeModels(),
   modeExtraArgs: getModeExtraArgs(),
+  modeProviders: getModeProviders(),
 
   // API Keys configuration
   ...getApiKeys(),

src/patch.ts

@@ -25,6 +25,7 @@ export interface PatchOptions {
   openaiKey?: string;
   anthropicKey?: string;
   openrouterKey?: string;
+  modelProvider?: string;
 }
 
 // Model provider interface for better abstraction
@@ -238,11 +239,12 @@ export class PatchClient {
       excludeFiles: options.excludeFiles || config.excludeFiles,
       openaiKey: options.openaiKey,
       anthropicKey: options.anthropicKey,
-      openrouterKey: options.openrouterKey
+      openrouterKey: options.openrouterKey,
+      modelProvider: options.modelProvider || config.modelProvider
     };
 
     // Create the appropriate model provider
-    this.modelProvider = createModelProvider(this.options);
+    this.modelProvider = this.getModelProvider();
   }
 
   /**
@@ -319,6 +321,30 @@ export class PatchClient {
    * Get the model-specific provider for the current configuration
    */
   private getModelProvider(): ModelProvider {
+    // First check for explicitly configured provider
+    const provider = this.getProviderForCurrentMode();
+    
+    if (provider) {
+      // Use explicitly configured provider
+      switch (provider) {
+        case 'anthropic':
+          return new AnthropicProvider(
+            this.options.anthropicKey, 
+            config.anthropicKeys
+          );
+        case 'openrouter':
+          return new OpenRouterProvider(
+            this.options.openrouterKey || config.openrouterKey
+          );
+        case 'openai':
+          return new OpenAIProvider(
+            this.options.openaiKey, 
+            config.openaiKeys
+          );
+      }
+    }
+    
+    // If no explicit provider, fall back to model name detection
     const modelName = this.getModelForCurrentMode();
 
     if (modelName.includes('claude')) {
@@ -337,6 +363,29 @@ export class PatchClient {
     }
   }
 
+  /**
+   * Get the provider for the current mode, prioritizing mode-specific settings
+   */
+  private getProviderForCurrentMode(): string | undefined {
+    // Check if we have mode-specific provider
+    if (config.modeProviders && this.options.mode && config.modeProviders[this.options.mode]) {
+      return config.modeProviders[this.options.mode];
+    }
+    
+    // Check for default provider in mode providers
+    if (config.modeProviders && config.modeProviders['default']) {
+      return config.modeProviders['default'];
+    }
+    
+    // Check for global provider
+    if (this.options.modelProvider) {
+      return this.options.modelProvider;
+    }
+    
+    // Finally check for config default
+    return config.modelProvider;
+  }
+  
   /**
    * Get the correct model for the current mode, prioritizing mode-specific settings
    */