fastlane-plugin-translate_gpt_release_notes 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e58b5b90b41cfb4c9865a1749550d3ebc9a5af135fca5ca666131a94021e2f8a
-  data.tar.gz: f847030d39a98cd54fdf50d19c86b4b37e64e2eb19366145cf3e8bfd5110f4f4
+  metadata.gz: 409b1bcd2c73ee2accc11399a91ffb090bbecd3ae523950e1e15583327702d9e
+  data.tar.gz: 1ee83d987e74e9dbbb2e903940cdc74eff26476ab436f0637b2ff5681dddb455
 SHA512:
-  metadata.gz: df687f2d1dc2d26c7bc9364eb870ac06f8ae89faf38371cc8981e973d599350b21de5d88e256424ad89bd6439aa9c24349b8e3f80beb6b31c29cb32bcc7f7662
-  data.tar.gz: 6c5f4587ef5620db5e1027591753b8c2596857f3aac1b5717610ac16cd77e439f3787517851ed0fecd5e2d46aa25a2ba1383b879aa111fa7968d01ea437175e7
+  metadata.gz: e64e5272e48df8a01e1a28b625d31a4c859ce7c1e3998a6116ddbb4eed11f9d157eb12e801090d3ee84e0a7175c632f86515f270a55c1e792777c0f8425236cb
+  data.tar.gz: 8f5c8d58a9ffc296c035946d303c3439877d24d39262f17231d7fd1d771054a247202ecddd91b1e6a6fc9877db3613c325bc59eec0e673e1c1f10be33fef6c87

data/README.md

@@ -6,7 +6,7 @@
 
 ## Getting Started
 
-This project is a [fastlane](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-translate_gpt`, add it to your project by running:
+This project is a [fastlane](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-translate_gpt_release_notes`, add it to your project by running:
 
 ```bash
 fastlane add_plugin translate_gpt_release_notes
@@ -15,95 +15,399 @@ fastlane add_plugin translate_gpt_release_notes
 ### Requirements
 
 - Ruby >= 3.1
-- OpenAI API key
+- API key for at least one supported translation provider
 
 **Note**: This plugin requires Ruby 3.1 or higher to ensure compatibility with the latest security patches in nokogiri.
 
 ## About translate-gpt-release-notes
 
-`translate-gpt-release-notes` is a fastlane plugin that allows you to translate release notes or changelogs for iOS and Android apps using OpenAI GPT API. Based on [translate-gpt by ftp27](https://github.com/ftp27/fastlane-plugin-translate_gpt).
+`translate-gpt-release-notes` is a fastlane plugin that allows you to translate release notes or changelogs for iOS and Android apps using multiple AI translation providers. Based on [translate-gpt by ftp27](https://github.com/ftp27/fastlane-plugin-translate_gpt).
 
+### Supported Translation Providers
 
-## How it works:
+The plugin now supports **4 translation providers**, giving you flexibility to choose based on cost, quality, and availability:
 
-`translate-gpt-release-notes` takes the changelog file for master locale (default: en-US), detects other locales based on fastlane metadata folder structure, translates changelog to all other languages with OpenAI API and creates localized .txt changelong files in respective folders
+| Provider | Best For | Quality | Cost | Speed |
+|----------|----------|---------|------|-------|
+| **OpenAI GPT** | General purpose, flexible translations | ⭐⭐⭐⭐⭐ | $$$ | Fast |
+| **Anthropic Claude** | High-quality, nuanced translations | ⭐⭐⭐⭐⭐ | $$$ | Medium |
+| **Google Gemini** | Cost-effective, high-volume translations | ⭐⭐⭐⭐ | $ | Fast |
+| **DeepL** | European languages, specialized translation | ⭐⭐⭐⭐⭐ | $$ | Fast |
 
-## Example
+## How it works
 
-The following example demonstrates how to use `translate-gpt-release-notes` in a `Fastfile`
+`translate-gpt-release-notes` takes the changelog file for the master locale (default: en-US), detects other locales based on the fastlane metadata folder structure, translates the changelog to all other languages using your chosen AI provider, and creates localized `.txt` changelog files in their respective folders.
+
+## Quick Start
+
+### 1. Configure your API key
+
+Choose your preferred provider and set the corresponding environment variable:
+
+```bash
+# Option 1: OpenAI (default)
+export OPENAI_API_KEY='your-openai-api-key'
+# Or use the legacy variable (still supported)
+export GPT_API_KEY='your-openai-api-key'
+
+# Option 2: Anthropic Claude
+export ANTHROPIC_API_KEY='your-anthropic-api-key'
+
+# Option 3: Google Gemini
+export GEMINI_API_KEY='your-gemini-api-key'
+
+# Option 4: DeepL
+export DEEPL_API_KEY='your-deepl-api-key'
+```
+
+### 2. Use in your Fastfile
 
 ```ruby
-  lane :translate_release_notes do
-    translate_gpt_release_notes(
-      master_locale: 'en-US',
-      platform: 'ios',
-      context: 'This is an app about cute kittens',
-      model_name: 'gpt-5.2',
-      service_tier: 'flex',
-      request_timeout: 900
-      # other parameters...
-    )
+lane :translate_release_notes do
+  translate_gpt_release_notes(
+    master_locale: 'en-US',
+    platform: 'ios',
+    context: 'This is an app about cute kittens'
+  )
 end
 ```
 
-## Options
+## Provider Selection
 
-The following options are available for `translate-gpt-release-notes`:
+### Default Provider
 
-| Key | Description | Environment Variable |
-| --- | --- | --- |
-| `api_token` | The API key for your OpenAI GPT account. | `GPT_API_KEY` |
-| `model_name` | Name of the ChatGPT model to use (default: gpt-5.2) | `GPT_MODEL_NAME` |
-| `service_tier` | OpenAI service tier to use (auto, default, flex, or priority). | `GPT_SERVICE_TIER` |
-| `temperature` | What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. Defaults to 0.5 | `GPT_TEMPERATURE` |
-| `request_timeout` | Timeout for the request in seconds. Defaults to 30 seconds. If `service_tier` is `flex` and this is lower than 900, the plugin increases it to 900. | `GPT_REQUEST_TIMEOUT` |
-| `master_locale` | Master language/locale for the source texts | `MASTER_LOCALE` |
-| `context` | Context for translation to improve accuracy | `GPT_CONTEXT` |
-| `platform` | Platform for which to translate (ios or android, defaults to ios).| `PLATFORM` |
+By default, the plugin uses **OpenAI** as the translation provider. This ensures backward compatibility with existing setups.
 
-## Authentication
+### Selecting a Provider
+
+You can explicitly select a provider using the `provider` parameter:
+
+```ruby
+# Use Anthropic Claude
+translate_gpt_release_notes(
+  provider: 'anthropic',
+  master_locale: 'en-US',
+  platform: 'ios'
+)
 
-`translate-gpt-release-notes` supports multiple authentication methods for the OpenAI GPT API:
+# Use Google Gemini
+translate_gpt_release_notes(
+  provider: 'gemini',
+  master_locale: 'en-US',
+  platform: 'ios'
+)
 
-### API Key
+# Use DeepL
+translate_gpt_release_notes(
+  provider: 'deepl',
+  master_locale: 'en-US',
+  platform: 'ios'
+)
+```
 
-You can provide your API key directly as an option to `translate-gpt`:
+Or set the default provider via environment variable:
+
+```bash
+export TRANSLATION_PROVIDER='anthropic'
+```
+
+## Usage Examples by Provider
+
+### OpenAI (Default)
 
 ```ruby
 translate_gpt_release_notes(
-  api_token: 'YOUR_API_KEY',
+  provider: 'openai',              # Optional, this is the default
+  openai_api_key: 'sk-...',        # Or use OPENAI_API_KEY env var
+  model_name: 'gpt-5.2',           # Default model
+  service_tier: 'flex',            # Options: auto, default, flex, priority
+  temperature: 0.5,                # 0-2, lower = more deterministic
   master_locale: 'en-US',
   platform: 'ios',
-  model_name: 'gpt-5.2',
-  context: 'This is an app about cute kittens'
+  context: 'Fitness tracking app'
+)
+```
 
+### Anthropic Claude
+
+```ruby
+translate_gpt_release_notes(
+  provider: 'anthropic',
+  anthropic_api_key: 'sk-ant-...', # Or use ANTHROPIC_API_KEY env var
+  model_name: 'claude-sonnet-4.5', # Default model
+  temperature: 0.5,                # 0-1 for Anthropic
+  master_locale: 'en-US',
+  platform: 'ios',
+  context: 'Finance management app'
+)
+```
+
+### Google Gemini
+
+```ruby
+translate_gpt_release_notes(
+  provider: 'gemini',
+  gemini_api_key: '...',           # Or use GEMINI_API_KEY env var
+  model_name: 'gemini-2.5-flash',  # Default model
+  temperature: 0.5,                # 0-1 for Gemini
+  master_locale: 'en-US',
+  platform: 'android',
+  context: 'Social media app'
+)
+```
+
+### DeepL
+
+```ruby
+translate_gpt_release_notes(
+  provider: 'deepl',
+  deepl_api_key: '...',            # Or use DEEPL_API_KEY env var
+  formality: 'less',               # Options: default, more, less
+  master_locale: 'en-US',
+  platform: 'ios',
+  context: 'Casual gaming app'
 )
 ```
 
-### Environment Variable
+**Note**: DeepL automatically detects free vs paid API keys (free keys end with `:fx`) and uses the appropriate endpoint.
+
+## Options
+
+### Core Options
+
+| Key | Description | Environment Variable | Default |
+|-----|-------------|---------------------|---------|
+| `provider` | Translation provider to use (`openai`, `anthropic`, `gemini`, `deepl`) | `TRANSLATION_PROVIDER` | `openai` |
+| `master_locale` | Master language/locale for the source texts | `MASTER_LOCALE` | `en-US` |
+| `platform` | Platform (`ios` or `android`) | `PLATFORM` | `ios` |
+| `context` | Context for translation to improve accuracy | `GPT_CONTEXT` | - |
+
+### Provider-Specific API Keys
+
+| Key | Description | Environment Variable |
+|-----|-------------|---------------------|
+| `openai_api_key` | OpenAI API key | `OPENAI_API_KEY` or `GPT_API_KEY` |
+| `anthropic_api_key` | Anthropic API key | `ANTHROPIC_API_KEY` |
+| `gemini_api_key` | Google Gemini API key | `GEMINI_API_KEY` |
+| `deepl_api_key` | DeepL API key | `DEEPL_API_KEY` |
+
+### OpenAI-Specific Options
+
+| Key | Description | Environment Variable | Default |
+|-----|-------------|---------------------|---------|
+| `model_name` | OpenAI model to use | `GPT_MODEL_NAME` | `gpt-5.2` |
+| `service_tier` | Service tier: `auto`, `default`, `flex`, `priority` | `GPT_SERVICE_TIER` | - |
+| `temperature` | Sampling temperature (0-2) | `GPT_TEMPERATURE` | `0.5` |
+| `request_timeout` | Timeout in seconds (auto-bumped to 900s for flex) | `GPT_REQUEST_TIMEOUT` | `30` |
+
+### Anthropic-Specific Options
+
+| Key | Description | Environment Variable | Default |
+|-----|-------------|---------------------|---------|
+| `model_name` | Anthropic model to use | `ANTHROPIC_MODEL_NAME` | `claude-sonnet-4.5` |
+| `temperature` | Sampling temperature (0-1) | `ANTHROPIC_TEMPERATURE` | `0.5` |
+| `request_timeout` | Timeout in seconds | `ANTHROPIC_REQUEST_TIMEOUT` | `60` |
+
+### Google Gemini-Specific Options
+
+| Key | Description | Environment Variable | Default |
+|-----|-------------|---------------------|---------|
+| `model_name` | Gemini model to use | `GEMINI_MODEL_NAME` | `gemini-2.5-flash` |
+| `temperature` | Sampling temperature (0-1) | `GEMINI_TEMPERATURE` | `0.5` |
+| `request_timeout` | Timeout in seconds | `GEMINI_REQUEST_TIMEOUT` | `60` |
+
+### DeepL-Specific Options
 
-Alternatively, you can set the `GPT_API_KEY` environment variable with your API key:
+| Key | Description | Environment Variable | Default |
+|-----|-------------|---------------------|---------|
+| `formality` | Formality level: `default`, `more`, `less` | `DEEPL_FORMALITY` | `default` |
+| `request_timeout` | Timeout in seconds | `DEEPL_REQUEST_TIMEOUT` | `30` |
+
+## Authentication
+
+### Environment Variables (Recommended)
+
+The recommended approach is to set API keys via environment variables:
 
 ```bash
-export GPT_API_KEY='YOUR_API_KEY'
+export OPENAI_API_KEY='sk-...'
+export ANTHROPIC_API_KEY='sk-ant-...'
+export GEMINI_API_KEY='...'
+export DEEPL_API_KEY='...'
 ```
 
-And then call `translate-gp-release-notes` without specifying an API key:
+### Direct Parameters
+
+Alternatively, pass API keys directly (useful for CI/CD with secrets):
 
 ```ruby
 translate_gpt_release_notes(
+  provider: 'anthropic',
+  anthropic_api_key: ENV['ANTHROPIC_API_KEY'],
   master_locale: 'en-US',
-  platform: 'ios',
+  platform: 'ios'
+)
+```
+
+### Multiple Providers Configuration
+
+You can configure multiple providers simultaneously and switch between them:
+
+```bash
+# Set up all providers
+export OPENAI_API_KEY='sk-...'
+export ANTHROPIC_API_KEY='sk-ant-...'
+export GEMINI_API_KEY='...'
+
+# Default to Gemini for cost savings
+export TRANSLATION_PROVIDER='gemini'
+```
+
+## Migration Guide
+
+### From Single-Provider Setup (v0.1.x)
+
+If you're upgrading from a previous version that only supported OpenAI:
+
+1. **No breaking changes** - Your existing setup will continue to work
+2. **Existing `GPT_API_KEY` still works** - No need to rename your environment variable
+3. **Default provider is OpenAI** - All existing configurations work unchanged
+
+Optional improvements you can make:
+- Rename `GPT_API_KEY` to `OPENAI_API_KEY` for clarity (both work)
+- Set `TRANSLATION_PROVIDER` if you want to experiment with other providers
+- Try different providers for different lanes (e.g., Gemini for development, Claude for production)
+
+### Example Migration
+
+**Before:**
+```ruby
+translate_gpt_release_notes(
+  api_token: ENV['GPT_API_KEY'],
   model_name: 'gpt-5.2',
-  context: 'This is an app about cute kittens'
+  master_locale: 'en-US'
 )
 ```
-## Important notes:
 
-1. Android has a limit of 500 symbols for changelogs and sometimes translations can exceed this number, which leads to Google API errors when submitting the app. Plugin **tries** to handle this, however errors happen. Reducing the length of master_locale changelog usually helps. iOS has a limit of 4000 symbols, which is plenty.
-2. OpenAI API usage cost money, keep it in mind.
-3. If you use `service_tier: 'flex'`, the plugin increases `request_timeout` to 900s when it is set lower.
-4. Hint: Flex processing trades higher latency for lower prices, which can reduce costs for non-urgent translations.
+**After** (still works, but cleaner):
+```ruby
+translate_gpt_release_notes(
+  provider: 'openai',
+  master_locale: 'en-US'
+)
+```
+
+## Important Notes
+
+### Android 500 Character Limit
+
+Android has a limit of 500 characters for changelogs. The plugin handles this in two ways:
+
+1. **AI Providers (OpenAI, Anthropic, Gemini)**: The character limit is included in the translation prompt, asking the AI to stay within the limit
+2. **DeepL**: Translations are truncated to 500 characters with a warning if they exceed the limit
+
+If you frequently hit the limit, consider shortening your master locale changelog.
+
+### iOS Character Limit
+
+iOS has a limit of 4000 characters, which is rarely an issue for release notes.
+
+### Cost Considerations
+
+All AI translation APIs cost money. Consider these tips:
+
+- Use `service_tier: 'flex'` with OpenAI for lower prices (trades latency for cost)
+- Google Gemini is generally the most cost-effective option
+- DeepL offers competitive pricing for European languages
+- The plugin skips translation if the source file hasn't changed (tracked via `last_successful_run.txt`)
+
+### Service Tiers (OpenAI)
+
+| Tier | Description | Use Case |
+|------|-------------|----------|
+| `auto` | Automatic tier selection | General use |
+| `default` | Standard processing | Urgent translations |
+| `flex` | Lower cost, higher latency | Non-urgent translations |
+| `priority` | Premium processing | Critical releases |
+
+**Note**: When using `flex`, the plugin automatically increases `request_timeout` to 900 seconds if set lower.
+
+## Troubleshooting
+
+### "No translation provider credentials configured"
+
+**Cause**: No API keys are set for any provider.
+
+**Solution**: Set at least one provider's API key:
+```bash
+export OPENAI_API_KEY='your-key-here'
+```
+
+### "Provider 'X' has no credentials"
+
+**Cause**: You specified a provider but haven't configured its API key.
+
+**Solution**: Either configure the provider's API key or switch to a provider with configured credentials.
+
+### "Invalid provider 'X'"
+
+**Cause**: The provider name is not recognized.
+
+**Solution**: Use one of the valid provider names: `openai`, `anthropic`, `gemini`, `deepl`.
+
+### Translations Exceed Android Character Limit
+
+**Cause**: The translated text is longer than 500 characters.
+
+**Solutions**:
+1. Shorten your source changelog
+2. For DeepL, translations are automatically truncated
+3. For AI providers, the prompt includes the limit but compliance isn't guaranteed
+
+### API Timeout Errors
+
+**Cause**: The translation request is taking too long.
+
+**Solutions**:
+1. Increase `request_timeout` parameter
+2. For OpenAI flex tier, timeout is automatically increased to 900s
+3. Consider using a faster provider (Gemini or DeepL)
+
+### Slow Translations with Flex Tier
+
+**Cause**: Flex tier trades latency for lower cost.
+
+**Solution**: This is expected behavior. If speed is critical, use `service_tier: 'default'` or `service_tier: 'priority'`.
+
+## Provider Comparison Details
+
+### When to Use Each Provider
+
+**OpenAI GPT**
+- ✅ Best for general-purpose translations
+- ✅ Flexible and customizable
+- ✅ Supports service tiers for cost control
+- ❌ Can be expensive for high volume
+
+**Anthropic Claude**
+- ✅ Highest quality nuanced translations
+- ✅ Excellent for complex or technical content
+- ✅ Strong reasoning capabilities
+- ❌ Slower than other options
+- ❌ Higher cost
+
+**Google Gemini**
+- ✅ Most cost-effective
+- ✅ Fast response times
+- ✅ Good quality for standard content
+- ❌ May struggle with very nuanced content
+
+**DeepL**
+- ✅ Best for European languages
+- ✅ Purpose-built for translation
+- ✅ Formality control
+- ❌ Limited language support compared to AI providers
+- ❌ May not handle app-specific context as well
 
 ## Issues and Feedback
 

data/lib/fastlane/plugin/translate_gpt_release_notes/actions/translate_gpt_release_notes_action.rb

@@ -1,12 +1,24 @@
 require 'fastlane/action'
-require 'openai'
 require_relative '../helper/translate_gpt_release_notes_helper'
+require_relative '../helper/credential_resolver'
+require_relative '../helper/providers/provider_factory'
 require 'fileutils'
 
 module Fastlane
   module Actions
     class TranslateGptReleaseNotesAction < Action
       def self.run(params)
+        provider_name = params[:provider] || 'openai'
+
+        unless Helper::CredentialResolver.credentials_exist?(provider_name, params)
+          available = Helper::CredentialResolver.available_providers(params)
+          if available.empty?
+            UI.user_error!("No translation provider credentials configured. Set one of: OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, or DEEPL_API_KEY")
+          else
+            UI.user_error!("Provider '#{provider_name}' has no credentials. Available providers: #{available.join(', ')}")
+          end
+        end
+
         # Define the path for the last run time file
         last_run_file = "last_successful_run.txt"
 
@@ -98,11 +110,60 @@ module Fastlane
       end
 
       def self.description
-        "Translate release notes or changelogs for iOS and Android apps using OpenAI's GPT API"
+        "Translate release notes using AI providers: OpenAI, Claude, Gemini, or DeepL"
       end
 
       def self.available_options
         [
+          FastlaneCore::ConfigItem.new(
+            key: :provider,
+            env_name: 'TRANSLATION_PROVIDER',
+            description: "Translation provider to use (#{Helper::Providers::ProviderFactory.available_provider_names.join(', ')})",
+            type: String,
+            default_value: 'openai',
+            verify_block: proc do |value|
+              unless Helper::Providers::ProviderFactory.valid_provider?(value)
+                available = Helper::Providers::ProviderFactory.available_provider_names.join(', ')
+                UI.user_error!("Invalid provider '#{value}'. Available: #{available}")
+              end
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :openai_api_key,
+            env_name: 'OPENAI_API_KEY',
+            description: 'OpenAI API key (alternative to environment variable)',
+            sensitive: true,
+            code_gen_sensitive: true,
+            optional: true,
+            default_value: nil
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :anthropic_api_key,
+            env_name: 'ANTHROPIC_API_KEY',
+            description: 'Anthropic API key (alternative to environment variable)',
+            sensitive: true,
+            code_gen_sensitive: true,
+            optional: true,
+            default_value: nil
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :gemini_api_key,
+            env_name: 'GEMINI_API_KEY',
+            description: 'Google Gemini API key (alternative to environment variable)',
+            sensitive: true,
+            code_gen_sensitive: true,
+            optional: true,
+            default_value: nil
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :deepl_api_key,
+            env_name: 'DEEPL_API_KEY',
+            description: 'DeepL API key (alternative to environment variable)',
+            sensitive: true,
+            code_gen_sensitive: true,
+            optional: true,
+            default_value: nil
+          ),
           FastlaneCore::ConfigItem.new(
             key: :api_token,
             env_name: "GPT_API_KEY",
@@ -114,7 +175,7 @@ module Fastlane
           FastlaneCore::ConfigItem.new(
             key: :model_name,
             env_name: "GPT_MODEL_NAME",
-            description: "Name of the ChatGPT model to use",
+            description: "Name of the AI model to use (provider-specific)",
             default_value: "gpt-5.2"
           ),
           FastlaneCore::ConfigItem.new(

data/lib/fastlane/plugin/translate_gpt_release_notes/helper/credential_resolver.rb

@@ -0,0 +1,118 @@
+module Fastlane
+  module Helper
+    # CredentialResolver manages multiple provider API keys simultaneously,
+    # allowing users to configure keys for all providers and select which
+    # to use via the provider parameter.
+    #
+    # This class provides a centralized way to resolve API credentials from
+    # various sources (parameters, environment variables) with a defined
+    # priority order.
+    class CredentialResolver
+      # Maps each provider to its credential configuration
+      # Each provider has:
+      # - env_vars: Array of environment variable names to check (in order)
+      # - param_key: Symbol for the parameter key in the params hash
+      PROVIDER_CREDENTIALS = {
+        'openai' => {
+          env_vars: ['OPENAI_API_KEY', 'GPT_API_KEY'],  # GPT_API_KEY for backward compatibility
+          param_key: :openai_api_key
+        },
+        'anthropic' => {
+          env_vars: ['ANTHROPIC_API_KEY'],
+          param_key: :anthropic_api_key
+        },
+        'gemini' => {
+          env_vars: ['GEMINI_API_KEY'],
+          param_key: :gemini_api_key
+        },
+        'deepl' => {
+          env_vars: ['DEEPL_API_KEY'],
+          param_key: :deepl_api_key
+        }
+      }.freeze
+
+      # Resolves the API key for a given provider following priority order:
+      # 1. Direct parameter (e.g., params[:openai_api_key])
+      # 2. Environment variables in order defined in PROVIDER_CREDENTIALS
+      # 3. Legacy fallback for OpenAI (GPT_API_KEY) if defined in env_vars
+      #
+      # @param provider_name [String] The provider identifier (e.g., 'openai', 'anthropic')
+      # @param params [Hash] Hash of parameters that may contain API keys
+      # @return [String, nil] The resolved API key or nil if not found
+      def self.resolve(provider_name, params = {})
+        config = provider_config(provider_name)
+        return nil unless config
+
+        # Priority 1: Check direct parameter
+        param_value = params[config[:param_key]]
+        return param_value.to_s.strip unless param_value.nil? || param_value.to_s.strip.empty?
+
+        # Priority 2: Check environment variables in order
+        config[:env_vars].each do |env_var|
+          env_value = ENV[env_var]
+          return env_value.to_s.strip unless env_value.nil? || env_value.to_s.strip.empty?
+        end
+
+        nil
+      end
+
+      # Checks if credentials exist for a given provider.
+      #
+      # @param provider_name [String] The provider identifier
+      # @param params [Hash] Hash of parameters that may contain API keys
+      # @return [Boolean] true if credentials exist, false otherwise
+      def self.credentials_exist?(provider_name, params = {})
+        !resolve(provider_name, params).nil?
+      end
+
+      # Returns an array of provider names that have configured credentials.
+      #
+      # @param params [Hash] Hash of parameters that may contain API keys
+      # @return [Array<String>] Array of provider names with valid credentials
+      def self.available_providers(params = {})
+        PROVIDER_CREDENTIALS.keys.select do |provider_name|
+          credentials_exist?(provider_name, params)
+        end
+      end
+
+      # Returns help text explaining how to configure credentials for a provider.
+      #
+      # @param provider_name [String] The provider identifier
+      # @return [String] Help text for configuring credentials
+      def self.credential_help(provider_name)
+        config = provider_config(provider_name)
+        return "Unknown provider: #{provider_name}" unless config
+
+        env_vars = config[:env_vars]
+        param_key = config[:param_key]
+
+        if env_vars.length == 1
+          "Set #{env_vars.first} environment variable, or pass :#{param_key} parameter"
+        else
+          env_vars_str = env_vars.join(' or ')
+          "Set #{env_vars_str} environment variable, or pass :#{param_key} parameter"
+        end
+      end
+
+      # Returns an array of all supported provider names.
+      #
+      # @return [Array<String>] Array of all supported provider names
+      def self.all_providers
+        PROVIDER_CREDENTIALS.keys.freeze
+      end
+
+      private
+
+      # Retrieves the credential configuration for a provider.
+      # Handles case-insensitive provider names by downcasing.
+      #
+      # @param provider_name [String] The provider identifier
+      # @return [Hash, nil] The credential configuration or nil if provider not found
+      def self.provider_config(provider_name)
+        return nil if provider_name.nil?
+
+        PROVIDER_CREDENTIALS[provider_name.to_s.downcase]
+      end
+    end
+  end
+end