aicli 0.1.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38ddbde1455388bed7ee62cff84c0aaa5cbc7329b0210fb88aacdf9fe39a0e13
-  data.tar.gz: 645ca62e82b191c88951293c8b04263428c7d5c3e4dfa7e6481db6ff59771a1c
+  metadata.gz: 49c27ca0316a3ca251344ea8a63589d603d67a6a89e77287b6615f9314650ed1
+  data.tar.gz: c44be18b27d259f0fd8f93f2133246775d042ab09576be64dc8138353d53d095
 SHA512:
-  metadata.gz: a36e4429798ec0261b2d65b39d038e6276d7680ed87d042d8b8a20b5ede788b5ba5010303103d36c87f25b69ebdcd520ed651f4668110d0ad3d341fb6d0852bf
-  data.tar.gz: 68d9f6c8c3789eca4c5b9ff4e65e31d3598ab5f917985293dab89048c3651ba20ba7761fa46c06f04b06f247b0316adb785c0d0cb611955ae1db032a42f6a85c
+  metadata.gz: becb34f20ed09c6d7de4f68c72b81aa6ae83cb72bf158e401c35bdabc291a2339d2fa16d845abf6934c826d1be0cbb50f48f45e9bec08a7c554a3e79bf8ba5c3
+  data.tar.gz: 9dc02259b8ea17da0d3a73aaade312cc88a0c234b9c6418014ac840025f8b440c9c735ac605165b898b00fe1e53e37f14365c60943652b6561e8ffa0b603f0ad

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.2.2
+
+- Improve `ai update`: compare installed version with RubyGems, install latest explicitly, clearer status messages
+
+## 0.2.1
+
+- Fix provider/model sync so Anthropic models are not sent to OpenAI
+- Show active `provider / model` on each run
+- Clearer error when a model is unavailable for the API key
+- `config set MODEL=...` infers PROVIDER from the RubyLLM registry
+
+## 0.2.0
+
+- Add Anthropic provider alongside OpenAI
+- Route all LLM calls through RubyLLM
+- Choose provider and model in `aicli config` (model list from RubyLLM registry)
+- Config keys: `PROVIDER`, `ANTHROPIC_KEY` (plus existing `OPENAI_KEY` / `MODEL`)
+
+## 0.1.0
+
+- Initial RubyGems release as `aicli`
+
 ## 1.0.12
 
 - Bug fixes

data/README.md

@@ -38,16 +38,25 @@ Ruby port by [Antonio Molinari](https://github.com/magnum), inspired by the orig
    gem build aicli.gemspec && gem install ./aicli-*.gem
    ```
 
-2. Retrieve your API key from [OpenAI](https://platform.openai.com/account/api-keys)
+2. Choose a provider and set the matching API key.
 
-   > Note: If you haven't already, you'll have to create an account and set up billing.
-
-3. Set the key so aicli can use it:
+   **OpenAI** (default) — key from [OpenAI](https://platform.openai.com/account/api-keys):
 
    ```sh
+   aicli config set PROVIDER=openai
    aicli config set OPENAI_KEY=<your token>
    ```
 
+   **Anthropic** — key from [Anthropic](https://console.anthropic.com/settings/keys):
+
+   ```sh
+   aicli config set PROVIDER=anthropic
+   aicli config set ANTHROPIC_KEY=<your token>
+   ```
+
+   Or use the interactive UI (`aicli config`) to pick provider, key, and model.
+   Model lists come from the [RubyLLM](https://rubyllm.com/models/) registry.
+
    This will create a `.aicli` file in your home directory.
 
 ## Usage
@@ -94,7 +103,20 @@ Or save the preference:
 aicli config set SILENT_MODE=true
 ```
 
-### Custom API endpoint
+### Provider and model
+
+```sh
+aicli config set PROVIDER=openai      # or anthropic
+aicli config set MODEL=gpt-4o-mini    # provider-specific model id
+```
+
+Defaults: `gpt-4o-mini` (OpenAI), `claude-sonnet-4-6` (Anthropic).
+
+LLM calls go through [RubyLLM](https://rubyllm.com/), so chat streaming and model metadata stay provider-agnostic.
+
+### Custom OpenAI API endpoint
+
+Useful for OpenAI-compatible proxies (ignored for Anthropic):
 
 ```sh
 aicli config set OPENAI_API_ENDPOINT=<your proxy endpoint>
@@ -148,20 +170,32 @@ aicli update
 
 ## Development
 
+Run the local checkout (not the installed gem) with Bundler from this directory:
+
 ```sh
 bundle install
-bundle exec bin/aicli --help
-bundle exec bin/aicli config set OPENAI_KEY=<your token>
-bundle exec bin/aicli list all log files
+
+bundle exec bin/ai --help
+bundle exec bin/ai config
+bundle exec bin/ai chat
+bundle exec bin/ai list all log files
 ```
 
-## Common Issues
+`bin/aicli` is equivalent to `bin/ai`. `bundle exec` loads dependencies from the Gemfile and code from `lib/`.
 
-### 429 error
+Example config for local testing:
+
+```sh
+bundle exec bin/ai config set PROVIDER=openai
+bundle exec bin/ai config set OPENAI_KEY=<your token>
+# or: PROVIDER=anthropic + ANTHROPIC_KEY=<your token>
+```
+
+## Common Issues
 
-This is due to incorrect billing setup or excessive quota usage. Please follow [this guide](https://help.openai.com/en/articles/6891831-error-code-429-you-exceeded-your-current-quota-please-check-your-plan-and-billing-details) to fix it.
+### Rate limit / quota errors
 
-You can activate billing at [this link](https://platform.openai.com/account/billing/overview).
+Usually billing or quota on the configured provider (OpenAI or Anthropic). Check that provider’s console billing page and that the matching API key is set in `~/.aicli`.
 
 ## Motivation
 

data/lib/aicli/cli.rb

@@ -86,9 +86,9 @@ module AiCli
       Commands::Update.run
     end
 
-    map %w[--version -v] => :__print_version
+    map %w[--version -v] => :version
     desc 'version', 'Print version'
-    def __print_version
+    def version
       puts AiCli::VERSION
     end
 

data/lib/aicli/commands/chat.rb

@@ -11,16 +11,14 @@ module AiCli
 
       def run
         config = Helpers::Config.get
-        key = config['OPENAI_KEY']
-        model = config['MODEL']
-        api_endpoint = config['OPENAI_API_ENDPOINT']
-        chat_history = []
+        chat = Helpers::Completion.start_chat(config)
 
         pastel = Pastel.new
         prompt = TTY::Prompt.new(interrupt: :exit)
 
         puts ''
         puts "┌  #{Helpers::I18n.t('Starting new conversation')}"
+        puts pastel.dim("   #{config['PROVIDER']} / #{config['MODEL']}")
 
         loop do
           user_prompt = prompt.ask(pastel.cyan("#{Helpers::I18n.t('You')}:")) do |q|
@@ -35,22 +33,25 @@ module AiCli
 
           spinner = TTY::Spinner.new("[:spinner] #{Helpers::I18n.t('THINKING...')}", format: :dots)
           spinner.auto_spin
-
-          chat_history << { 'role' => 'user', 'content' => user_prompt }
-
-          stream_lines = Helpers::Completion.generate_completion(
-            prompt: chat_history,
-            key: key,
-            model: model,
-            api_endpoint: api_endpoint
+          started = false
+
+          Helpers::Completion.stream_chat_message(
+            chat,
+            user_prompt,
+            writer: lambda { |chunk|
+              unless started
+                spinner.success(pastel.green('aicli:'))
+                puts ''
+                started = true
+              end
+              print chunk
+            }
           )
-          enumerator = stream_lines.each
-          read_response = Helpers::Completion.read_data(enumerator)
 
-          spinner.success(pastel.green('aicli:'))
-          puts ''
-          full_response = read_response.call(->(chunk) { print chunk })
-          chat_history << { 'role' => 'assistant', 'content' => full_response }
+          unless started
+            spinner.success(pastel.green('aicli:'))
+            puts ''
+          end
           puts ''
           puts ''
         end

data/lib/aicli/commands/update.rb

@@ -1,21 +1,83 @@
 # frozen_string_literal: true
 
+require 'json'
+require 'net/http'
+require 'uri'
 require 'pastel'
 
 module AiCli
   module Commands
     module Update
+      RUBYGEMS_GEM_URI = 'https://rubygems.org/api/v1/gems/aicli.json'
+
       module_function
 
       def run
         pastel = Pastel.new
+        current = Gem::Version.new(AiCli::VERSION)
+
+        puts ''
+        puts pastel.dim("Current version: #{current}")
+
+        latest_str = fetch_latest_version
+        latest = Gem::Version.new(latest_str)
+        puts pastel.dim("Latest on RubyGems: #{latest}")
         puts ''
-        command = 'gem update aicli'
-        puts pastel.dim("#{Helpers::I18n.t('Running')}: #{command}")
+
+        if latest < current
+          puts pastel.yellow(
+            "Installed #{current} is newer than RubyGems #{latest}. Skipping update."
+          )
+          puts pastel.dim('Publish a new version, then run `ai update` again.')
+          return
+        end
+
+        if latest == current
+          puts pastel.green("Already up to date (#{current}).")
+          return
+        end
+
+        command = ['gem', 'install', 'aicli', '-v', latest_str]
+        puts pastel.dim("#{Helpers::I18n.t('Running')}: #{command.join(' ')}")
         puts ''
-        system(command)
+
+        ok = system(*command)
         puts ''
+
+        unless ok
+          raise Helpers::KnownError,
+                'Failed to update aicli. Try manually: gem install aicli'
+        end
+
+        puts pastel.green("Updated aicli to #{latest}.")
+        puts pastel.dim('Open a new shell if `ai version` still shows the old number.')
+      rescue Helpers::KnownError => e
+        puts "\n#{pastel.red('✖')} #{e.message}"
+        exit 1
+      rescue StandardError => e
+        puts "\n#{pastel.red('✖')} Could not check RubyGems for updates: #{e.message}"
+        Helpers::Error.handle_cli_error(e)
+        exit 1
+      end
+
+      def fetch_latest_version
+        uri = URI(RUBYGEMS_GEM_URI)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          http.open_timeout = 10
+          http.read_timeout = 10
+          http.get(uri.request_uri)
+        end
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "RubyGems returned HTTP #{response.code}"
+        end
+
+        version = JSON.parse(response.body)['version'].to_s
+        raise 'RubyGems response missing version' if version.empty?
+
+        version
       end
+      private_class_method :fetch_latest_version
     end
   end
 end

data/lib/aicli/helpers/completion.rb

@@ -1,219 +1,66 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'net/http'
-require 'uri'
-require 'thread'
-
 module AiCli
   module Helpers
     module Completion
       EXPLAIN_IN_SECOND_REQUEST = true
-      SHELL_CODE_EXCLUSIONS = [/```[a-zA-Z]*\n/i, /```[a-zA-Z]*/i, "\n"].freeze
+      SHELL_CODE_EXCLUSIONS = [/```[a-zA-Z]*\n?/i, /```[a-zA-Z]*/i, "\n"].freeze
 
       module_function
 
-      def get_script_and_info(prompt:, key:, api_endpoint:, model: nil)
-        stream = generate_completion(
-          prompt: full_prompt(prompt),
-          key: key,
-          model: model,
-          api_endpoint: api_endpoint
-        )
-        enumerator = stream.each
-
+      def get_script_and_info(prompt:, config:)
         {
-          read_script: read_data(enumerator, *SHELL_CODE_EXCLUSIONS),
-          read_info: read_data(enumerator, *SHELL_CODE_EXCLUSIONS)
+          read_script: stream_prompt(full_prompt(prompt), config: config, exclusions: SHELL_CODE_EXCLUSIONS),
+          read_info: ->(_writer) { '' }
         }
       end
 
-      def get_explanation(script:, key:, api_endpoint:, model: nil)
-        stream = generate_completion(
-          prompt: explanation_prompt(script),
-          key: key,
-          model: model,
-          api_endpoint: api_endpoint
-        )
-        { read_explanation: read_data(stream.each) }
-      end
-
-      def get_revision(prompt:, code:, key:, api_endpoint:, model: nil)
-        stream = generate_completion(
-          prompt: revision_prompt(prompt, code),
-          key: key,
-          model: model,
-          api_endpoint: api_endpoint
-        )
-        { read_script: read_data(stream.each, *SHELL_CODE_EXCLUSIONS) }
-      end
-
-      def get_models(key, api_endpoint)
-        uri = URI.join(ensure_trailing_slash(api_endpoint), 'models')
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == 'https'
-
-        request = Net::HTTP::Get.new(uri)
-        request['Authorization'] = "Bearer #{key}"
-        request['Content-Type'] = 'application/json'
-
-        response = http.request(request)
-        raise KnownError, "Failed to list models: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-
-        data = JSON.parse(response.body)
-        data.fetch('data', []).select { |m| m['object'] == 'model' }
+      def get_explanation(script:, config:)
+        { read_explanation: stream_prompt(explanation_prompt(script), config: config) }
       end
 
-      # Returns a live Enumerator of SSE "data: ..." lines
-      def generate_completion(prompt:, key:, api_endpoint:, model: nil, number: 1)
-        messages = if prompt.is_a?(Array)
-                     prompt
-                   else
-                     [{ 'role' => 'user', 'content' => prompt }]
-                   end
-
-        uri = URI.join(ensure_trailing_slash(api_endpoint), 'chat/completions')
-        body = {
-          model: model || 'gpt-4o-mini',
-          messages: messages,
-          n: [number, 10].min,
-          stream: true
+      def get_revision(prompt:, code:, config:)
+        {
+          read_script: stream_prompt(
+            revision_prompt(prompt, code),
+            config: config,
+            exclusions: SHELL_CODE_EXCLUSIONS
+          )
         }
+      end
 
-        queue = Queue.new
-        error_box = []
-
-        Thread.new do
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = uri.scheme == 'https'
-          http.read_timeout = 120
-
-          request = Net::HTTP::Post.new(uri)
-          request['Authorization'] = "Bearer #{key}"
-          request['Content-Type'] = 'application/json'
-          request['Accept'] = 'text/event-stream'
-          request.body = JSON.generate(body)
-
-          http.request(request) do |response|
-            unless response.is_a?(Net::HTTPSuccess)
-              error_box << [:api, response.code.to_i, response.body]
-              queue << :done
-              next
-            end
-
-            buffer = +''
-            response.read_body do |chunk|
-              buffer << chunk
-              while (eol = buffer.index("\n"))
-                line = buffer.slice!(0..eol).strip
-                queue << line if line.start_with?('data: ')
-              end
-            end
-          end
-          queue << :done
-        rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH => e
-          error_box << [:network, uri.host, e.message]
-          queue << :done
-        rescue StandardError => e
-          error_box << [:other, e]
-          queue << :done
-        end
-
-        Enumerator.new do |yielder|
-          loop do
-            item = queue.pop
-            break if item == :done
-
-            yielder << item
-          end
-
-          if (err = error_box.first)
-            case err[0]
-            when :api
-              handle_api_error(err[1], err[2])
-            when :network
-              raise KnownError,
-                    "Error connecting to #{err[1]}. Are you connected to the internet? (#{err[2]})"
-            when :other
-              raise err[1]
-            end
-          end
-        end
+      def get_models(provider)
+        Llm.list_chat_models(provider)
       end
 
-      def read_data(enumerator, *excluded)
+      # Streams a single-turn completion. Returns a callable that takes a writer.
+      def stream_prompt(prompt, config:, exclusions: [])
         lambda do |writer|
-          data = +''
-          data_start = false
-          buffer = +''
-          excluded_prefix = excluded.first
-
-          loop do
-            chunk = enumerator.next
-            payloads = chunk.to_s.split("\n\n")
-
-            payloads.each do |payload|
-              return data if payload.include?('[DONE]')
-
-              next unless payload.start_with?('data:')
-
-              content = parse_content(payload)
-
-              unless data_start
-                buffer << content
-                if excluded_prefix.nil? || buffer.match?(excluded_prefix)
-                  data_start = true
-                  buffer = +''
-                  break if excluded_prefix
-                end
-              end
-
-              next unless data_start && !content.empty?
-
-              cleaned = StripRegexPatterns.call(content, excluded)
-              data << cleaned
-              writer.call(cleaned)
-            end
-          rescue StopIteration
-            break
-          end
-
-          data
+          stream_to_writer(prompt, config: config, exclusions: exclusions, writer: writer)
         end
       end
 
-      def parse_content(payload)
-        raw = payload.sub(/^data:\s*/, '')
-        delta = JSON.parse(raw.strip)
-        delta.dig('choices', 0, 'delta', 'content') || ''
-      rescue JSON::ParserError => e
-        "Error with JSON.parse and #{payload}.\n#{e}"
+      # Multi-turn chat helper used by `aicli chat`.
+      def start_chat(config)
+        Llm.build_chat(config)
       end
 
-      def handle_api_error(status, body)
-        message_string = begin
-          JSON.pretty_generate(JSON.parse(body))
-        rescue StandardError
-          body.to_s
-        end
-
-        if status == 429
-          raise KnownError, <<~MSG
-            Request to OpenAI failed with status 429. This is due to incorrect billing setup or excessive quota usage. Please follow this guide to fix it: https://help.openai.com/en/articles/6891831-error-code-429-you-exceeded-your-current-quota-please-check-your-plan-and-billing-details
+      def stream_chat_message(chat, message, writer:)
+        data = +''
 
-            You can activate billing here: https://platform.openai.com/account/billing/overview . Make sure to add a payment method if not under an active grant from OpenAI.
+        begin
+          chat.ask(message) do |chunk|
+            content = chunk.content.to_s
+            next if content.empty?
 
-            Full message from OpenAI:
-
-            #{message_string}
-          MSG
+            data << content
+            writer.call(content)
+          end
+        rescue RubyLLM::Error, RubyLLM::ConfigurationError => e
+          handle_ruby_llm_error(e)
         end
 
-        raise KnownError, <<~MSG
-          Request to OpenAI failed with status #{status}:
-
-          #{message_string}
-        MSG
+        data
       end
 
       def explanation_prompt(script)
@@ -267,9 +114,84 @@ module AiCli
         PROMPT
       end
 
-      def ensure_trailing_slash(endpoint)
-        endpoint.end_with?('/') ? endpoint : "#{endpoint}/"
+      def stream_to_writer(prompt, config:, exclusions:, writer:)
+        chat = Llm.build_chat(config)
+        data = +''
+        data_start = exclusions.empty?
+        buffer = +''
+        excluded_prefix = exclusions.first
+
+        begin
+          chat.ask(prompt) do |chunk|
+            content = chunk.content.to_s
+            next if content.empty?
+
+            unless data_start
+              buffer << content
+              next unless excluded_prefix.nil? || buffer.match?(excluded_prefix)
+
+              data_start = true
+              remainder = StripRegexPatterns.call(buffer, exclusions)
+              buffer = +''
+              next if remainder.empty?
+
+              data << remainder
+              writer.call(remainder)
+              next
+            end
+
+            cleaned = StripRegexPatterns.call(content, exclusions)
+            next if cleaned.empty?
+
+            data << cleaned
+            writer.call(cleaned)
+          end
+        rescue RubyLLM::Error, RubyLLM::ConfigurationError => e
+          handle_ruby_llm_error(e)
+        end
+
+        data
+      end
+
+      def handle_ruby_llm_error(error)
+        message = error.message.to_s
+
+        if error.is_a?(RubyLLM::RateLimitError) || error.is_a?(RubyLLM::PaymentRequiredError) ||
+           message.match?(/rate.?limit|quota|billing/i)
+          raise KnownError, <<~MSG
+            Request to the LLM provider failed (rate limit / quota).
+
+            Check your plan and billing details for the configured provider, then try again.
+
+            Full message:
+
+            #{message}
+          MSG
+        end
+
+        if message.match?(/model_not_found|does not exist|do not have access/i)
+          raise KnownError, <<~MSG
+            The configured model is not available for this API key/provider.
+
+            Fix with:
+              #{Constants::COMMAND_NAME} config
+            or:
+              #{Constants::COMMAND_NAME} config set MODEL=#{Llm.default_model_for('anthropic')}
+              #{Constants::COMMAND_NAME} config set PROVIDER=anthropic
+
+            Full message:
+
+            #{message}
+          MSG
+        end
+
+        raise KnownError, <<~MSG
+          Request to the LLM provider failed:
+
+          #{message}
+        MSG
       end
+      private_class_method :stream_to_writer, :handle_ruby_llm_error
     end
   end
 end

data/lib/aicli/helpers/config.rb

@@ -11,15 +11,17 @@ module AiCli
       LEGACY_CONFIG_PATH = File.join(Dir.home, '.ai-shell')
 
       CONFIG_PARSERS = {
+        'PROVIDER' => lambda { |provider|
+          Llm.normalize_provider(provider)
+        },
         'OPENAI_KEY' => lambda { |key|
-          if key.nil? || key.empty?
-            raise KnownError,
-                  "Please set your OpenAI API key via `#{Constants::COMMAND_NAME} config set OPENAI_KEY=<your token>`"
-          end
-          key
+          key.to_s
+        },
+        'ANTHROPIC_KEY' => lambda { |key|
+          key.to_s
         },
         'MODEL' => lambda { |model|
-          model.nil? || model.empty? ? 'gpt-4o-mini' : model
+          model.to_s
         },
         'SILENT_MODE' => lambda { |mode|
           mode.to_s.downcase == 'true'
@@ -43,21 +45,48 @@ module AiCli
           parsed[key] = parser.call(value)
         end
 
+        raw_model = cli_config&.dig('MODEL') || config['MODEL']
+        if raw_model.nil? || raw_model.to_s.empty?
+          parsed['MODEL'] = Llm.default_model_for(parsed['PROVIDER'])
+        end
+
+        provider, model = Llm.resolve_provider_and_model(parsed)
+        parsed['PROVIDER'] = provider
+        parsed['MODEL'] = model
         parsed
       end
 
       def set(key_values)
         config = read_config_file
+        updates = {}
 
         key_values.each do |key, value|
           unless CONFIG_PARSERS.key?(key)
             raise KnownError, "#{I18n.t('Invalid config property')}: #{key}"
           end
 
-          parsed = CONFIG_PARSERS[key].call(value)
-          config[key] = parsed.to_s
+          updates[key] = CONFIG_PARSERS[key].call(value).to_s
+        end
+
+        # Keep PROVIDER and MODEL aligned with the RubyLLM registry.
+        if updates.key?('MODEL') && !updates['MODEL'].empty?
+          model_provider = Llm.provider_for_model(updates['MODEL'])
+          if model_provider
+            updates['PROVIDER'] = model_provider unless updates.key?('PROVIDER')
+          end
+        end
+
+        if updates.key?('PROVIDER')
+          provider = Llm.normalize_provider(updates['PROVIDER'])
+          updates['PROVIDER'] = provider
+          next_model = updates['MODEL'] || config['MODEL']
+          known_ids = Completion.get_models(provider).map { |m| m['id'] }
+          if next_model.to_s.empty? || !known_ids.include?(next_model)
+            updates['MODEL'] = Llm.default_model_for(provider) unless updates.key?('MODEL') && known_ids.include?(updates['MODEL'])
+          end
         end
 
+        updates.each { |key, value| config[key] = value }
         File.write(CONFIG_PATH, stringify_ini(config))
       end
 
@@ -72,8 +101,12 @@ module AiCli
         loop do
           config = get
           choice = prompt.select("#{I18n.t('Set config')}:") do |menu|
+            menu.choice "#{I18n.t('Provider')} (#{display_hint(config, 'PROVIDER')})",
+                        'PROVIDER'
             menu.choice "#{I18n.t('OpenAI Key')} (#{display_hint(config, 'OPENAI_KEY') { |v| "sk-...#{v[-3..]}" }})",
                         'OPENAI_KEY'
+            menu.choice "#{I18n.t('Anthropic Key')} (#{display_hint(config, 'ANTHROPIC_KEY') { |v| "...#{v[-3..]}" }})",
+                        'ANTHROPIC_KEY'
             menu.choice "#{I18n.t('OpenAI API Endpoint')} (#{display_hint(config, 'OPENAI_API_ENDPOINT')})",
                         'OPENAI_API_ENDPOINT'
             menu.choice "#{I18n.t('Silent Mode')} (#{display_hint(config, 'SILENT_MODE')})",
@@ -86,11 +119,27 @@ module AiCli
           end
 
           case choice
+          when 'PROVIDER'
+            provider = prompt.select(I18n.t('Pick a provider')) do |menu|
+              Llm::PROVIDERS.each { |p| menu.choice p, p }
+            end
+            updates = [['PROVIDER', provider]]
+            current_model = get['MODEL']
+            known_ids = Completion.get_models(provider).map { |m| m['id'] }
+            unless known_ids.include?(current_model)
+              updates << ['MODEL', Llm.default_model_for(provider)]
+            end
+            set(updates)
           when 'OPENAI_KEY'
             key = prompt.ask(I18n.t('Enter your OpenAI API key')) do |q|
               q.required true
             end
             set([['OPENAI_KEY', key]])
+          when 'ANTHROPIC_KEY'
+            key = prompt.ask(I18n.t('Enter your Anthropic API key')) do |q|
+              q.required true
+            end
+            set([['ANTHROPIC_KEY', key]])
           when 'OPENAI_API_ENDPOINT'
             api_endpoint = prompt.ask(I18n.t('Enter your OpenAI API Endpoint'))
             set([['OPENAI_API_ENDPOINT', api_endpoint]]) if api_endpoint
@@ -99,9 +148,17 @@ module AiCli
             set([['SILENT_MODE', silent ? 'true' : 'false']])
           when 'MODEL'
             cfg = get
-            models = Completion.get_models(cfg['OPENAI_KEY'], cfg['OPENAI_API_ENDPOINT'])
-            model = prompt.select('Pick a model.') do |menu|
-              models.each { |m| menu.choice m['id'], m['id'] }
+            models = Completion.get_models(cfg['PROVIDER'])
+            if models.empty?
+              puts pastel.yellow(I18n.t('No models found for this provider.'))
+              next
+            end
+            model = prompt.select(I18n.t('Pick a model.')) do |menu|
+              menu.default cfg['MODEL'] if models.any? { |m| m['id'] == cfg['MODEL'] }
+              models.each do |m|
+                label = m['name'].empty? || m['name'] == m['id'] ? m['id'] : "#{m['name']} (#{m['id']})"
+                menu.choice label, m['id']
+              end
             end
             set([['MODEL', model]])
           when 'LANGUAGE'
@@ -149,7 +206,7 @@ module AiCli
       end
 
       def display_hint(config, key)
-        if config.key?(key) && !config[key].nil?
+        if config.key?(key) && !config[key].nil? && !(config[key].respond_to?(:empty?) && config[key].empty?)
           value = config[key]
           block_given? ? yield(value) : value.to_s
         else

data/lib/aicli/helpers/llm.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'ruby_llm'
+
+module AiCli
+  module Helpers
+    module Llm
+      PROVIDERS = %w[openai anthropic].freeze
+
+      DEFAULT_MODELS = {
+        'openai' => 'gpt-4o-mini',
+        'anthropic' => 'claude-sonnet-4-6'
+      }.freeze
+
+      module_function
+
+      def configure!(config)
+        provider = normalize_provider(config['PROVIDER'])
+        ensure_credentials!(config, provider)
+
+        RubyLLM.configure do |c|
+          openai_key = config['OPENAI_KEY'].to_s
+          anthropic_key = config['ANTHROPIC_KEY'].to_s
+          endpoint = config['OPENAI_API_ENDPOINT'].to_s
+
+          c.openai_api_key = openai_key unless openai_key.empty?
+          c.anthropic_api_key = anthropic_key unless anthropic_key.empty?
+
+          if !endpoint.empty? && endpoint != 'https://api.openai.com/v1'
+            c.openai_api_base = endpoint.sub(%r{/+\z}, '')
+          end
+        end
+
+        provider
+      end
+
+      def build_chat(config)
+        provider, model = resolve_provider_and_model(config)
+        ensure_credentials!(config, provider)
+
+        configure!(config.merge('PROVIDER' => provider, 'MODEL' => model))
+
+        opts = { model: model, provider: provider.to_sym }
+        opts[:assume_model_exists] = true unless model_known?(model, provider)
+        RubyLLM.chat(**opts)
+      end
+
+      # Returns [provider, model], fixing mismatches against the RubyLLM registry.
+      def resolve_provider_and_model(config)
+        provider = normalize_provider(config['PROVIDER'])
+        model = config['MODEL'].to_s
+        model = default_model_for(provider) if model.empty?
+
+        model_provider = provider_for_model(model)
+        if model_provider && model_provider != provider
+          # Prefer the provider that actually owns the selected model.
+          provider = model_provider
+        elsif model_provider.nil? && !model_known?(model, provider)
+          # Unknown id for this provider: fall back to a safe default.
+          model = default_model_for(provider)
+        end
+
+        [provider, model]
+      end
+
+      def provider_for_model(model_id)
+        return nil if model_id.to_s.empty?
+
+        info = RubyLLM.models.find(model_id)
+        normalize_provider(info.provider)
+      rescue StandardError
+        # Try each known provider explicitly (aliases can be provider-specific).
+        PROVIDERS.each do |provider|
+          return provider if model_known?(model_id, provider)
+        end
+        nil
+      end
+
+      def list_chat_models(provider)
+        provider = normalize_provider(provider)
+
+        RubyLLM.models.chat_models
+               .by_provider(provider.to_sym)
+               .select { |m| text_chat_model?(m) }
+               .sort_by { |m| [m.name.to_s.downcase, m.id] }
+               .map { |m| { 'id' => m.id, 'name' => m.name.to_s } }
+      end
+
+      def default_model_for(provider)
+        DEFAULT_MODELS.fetch(normalize_provider(provider), DEFAULT_MODELS['openai'])
+      end
+
+      def normalize_provider(provider)
+        value = provider.to_s.downcase
+        PROVIDERS.include?(value) ? value : 'openai'
+      end
+
+      def ensure_credentials!(config, provider = nil)
+        provider = normalize_provider(provider || config['PROVIDER'])
+
+        case provider
+        when 'anthropic'
+          if config['ANTHROPIC_KEY'].to_s.empty?
+            raise KnownError,
+                  "Please set your Anthropic API key via `#{Constants::COMMAND_NAME} config set ANTHROPIC_KEY=<your token>`"
+          end
+        else
+          if config['OPENAI_KEY'].to_s.empty?
+            raise KnownError,
+                  "Please set your OpenAI API key via `#{Constants::COMMAND_NAME} config set OPENAI_KEY=<your token>`"
+          end
+        end
+      end
+
+      def model_known?(model, provider)
+        RubyLLM.models.find(model, provider.to_sym)
+        true
+      rescue StandardError
+        false
+      end
+
+      def text_chat_model?(model)
+        outputs = Array(model.modalities&.output).map(&:to_s)
+        return false unless outputs.include?('text')
+
+        !model.id.match?(/tts|transcribe|realtime|whisper|embedding|moderation|dall-e|imagen|search-preview|babbage|davinci|ada-|curie|instruct/i)
+      end
+    end
+  end
+end

data/lib/aicli/prompt.rb

@@ -14,14 +14,12 @@ module AiCli
       init_i18n
 
       config = Helpers::Config.get
-      key = config['OPENAI_KEY']
-      model = config['MODEL']
-      api_endpoint = config['OPENAI_API_ENDPOINT']
       skip_explanation = silent_mode || config['SILENT_MODE']
 
       pastel = Pastel.new
       puts ''
       puts "┌  #{pastel.cyan(Helpers::Constants::PROJECT_NAME)}"
+      puts pastel.dim("   #{config['PROVIDER']} / #{config['MODEL']}")
 
       the_prompt = use_prompt.nil? || use_prompt.strip.empty? ? ask_prompt : use_prompt
 
@@ -30,9 +28,7 @@ module AiCli
 
       result = Helpers::Completion.get_script_and_info(
         prompt: the_prompt,
-        key: key,
-        model: model,
-        api_endpoint: api_endpoint
+        config: config
       )
 
       spinner.success(Helpers::I18n.t('Your script') + ':')
@@ -50,9 +46,7 @@ module AiCli
         if info.nil? || info.empty?
           explanation = Helpers::Completion.get_explanation(
             script: script,
-            key: key,
-            model: model,
-            api_endpoint: api_endpoint
+            config: config
           )
           spinner.success(Helpers::I18n.t('Explanation') + ':')
           puts ''
@@ -65,7 +59,7 @@ module AiCli
         end
       end
 
-      run_or_revise_flow(script, key, model, api_endpoint, silent_mode)
+      run_or_revise_flow(script, config, silent_mode)
     end
 
     def init_i18n
@@ -102,14 +96,13 @@ module AiCli
     end
 
     def run_script(script)
-      pastel = Pastel.new
       puts "└  #{Helpers::I18n.t('Running')}: #{script}"
       puts ''
       system(ENV['SHELL'] || 'bash', '-c', script)
       Helpers::ShellHistory.append(script)
     end
 
-    def run_or_revise_flow(script, key, model, api_endpoint, silent_mode)
+    def run_or_revise_flow(script, config, silent_mode)
       prompt = TTY::Prompt.new(interrupt: :exit)
       empty_script = script.strip.empty?
 
@@ -132,7 +125,7 @@ module AiCli
         new_script = prompt.ask(Helpers::I18n.t('you can edit script here'), default: script)
         run_script(new_script) if new_script && !new_script.empty?
       when :revise
-        revision_flow(script, key, model, api_endpoint, silent_mode)
+        revision_flow(script, config, silent_mode)
       when :copy
         Clipboard.copy(script)
         puts "└  #{Helpers::I18n.t('Copied to clipboard!')}"
@@ -142,7 +135,7 @@ module AiCli
       end
     end
 
-    def revision_flow(current_script, key, model, api_endpoint, silent_mode)
+    def revision_flow(current_script, config, silent_mode)
       pastel = Pastel.new
       revision = ask_revision
 
@@ -152,9 +145,7 @@ module AiCli
       result = Helpers::Completion.get_revision(
         prompt: revision,
         code: current_script,
-        key: key,
-        model: model,
-        api_endpoint: api_endpoint
+        config: config
       )
 
       spinner.success(Helpers::I18n.t('Your new script') + ':')
@@ -170,9 +161,7 @@ module AiCli
 
         explanation = Helpers::Completion.get_explanation(
           script: script,
-          key: key,
-          model: model,
-          api_endpoint: api_endpoint
+          config: config
         )
 
         info_spinner.success(Helpers::I18n.t('Explanation') + ':')
@@ -183,7 +172,7 @@ module AiCli
         puts pastel.dim('•')
       end
 
-      run_or_revise_flow(script, key, model, api_endpoint, silent_mode)
+      run_or_revise_flow(script, config, silent_mode)
     end
 
     private_class_method :init_i18n, :examples, :ask_prompt, :ask_revision,

data/lib/aicli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AiCli
-  VERSION = '0.1.1'
+  VERSION = '0.2.2'
 end

data/lib/aicli.rb

@@ -7,6 +7,7 @@ require_relative 'aicli/helpers/i18n'
 require_relative 'aicli/helpers/os_detect'
 require_relative 'aicli/helpers/strip_regex_patterns'
 require_relative 'aicli/helpers/shell_history'
+require_relative 'aicli/helpers/llm'
 require_relative 'aicli/helpers/completion'
 require_relative 'aicli/helpers/config'
 require_relative 'aicli/prompt'

data/locales/en.yml

@@ -8,14 +8,20 @@ Please set your OpenAI API key via `ai config set OPENAI_KEY=<your token>`: Plea
   set your OpenAI API key via `ai config set OPENAI_KEY=<your token>`
 Set config: Set config
 Enter your OpenAI API key: Enter your OpenAI API key
+Enter your Anthropic API key: Enter your Anthropic API key
 "(not set)": "(not set)"
+Provider: Provider
+Pick a provider: Pick a provider
 OpenAI Key: OpenAI Key
+Anthropic Key: Anthropic Key
 Please enter a key: Please enter a key
 OpenAI API Endpoint: OpenAI API Endpoint
 Enter your OpenAI API Endpoint: Enter your OpenAI API Endpoint
 Silent Mode: Silent Mode
 Enable silent mode?: Enable silent mode?
 Model: Model
+Pick a model.: Pick a model.
+No models found for this provider.: No models found for this provider.
 Enter the model you want to use: Enter the model you want to use
 Language: Language
 Enter the language you want to use: Enter the language you want to use

data/locales/it.yml

@@ -8,14 +8,20 @@ Please set your OpenAI API key via `ai config set OPENAI_KEY=<your token>`: Per
   imposta la tua chiave API OpenAI tramite `ai config set OPENAI_KEY=<your token>`
 Set config: Imposta la configurazione
 Enter your OpenAI API key: Inserisci la tua chiave API OpenAI
+Enter your Anthropic API key: Inserisci la tua chiave API Anthropic
 "(not set)": "(non impostato)"
+Provider: Provider
+Pick a provider: Scegli un provider
 OpenAI Key: Chiave OpenAI
+Anthropic Key: Chiave Anthropic
 Please enter a key: Per favore inserisci una chiave
 OpenAI API Endpoint: Endpoint API OpenAI
 Enter your OpenAI API Endpoint: Inserisci il tuo endpoint API OpenAI
 Silent Mode: Modalità silenziosa
 Enable silent mode?: Abilitare la modalità silenziosa?
 Model: Modello
+Pick a model.: Scegli un modello.
+No models found for this provider.: Nessun modello trovato per questo provider.
 Enter the model you want to use: Inserisci il modello che vuoi utilizzare
 Language: Lingua
 Enter the language you want to use: Inserisci la lingua che vuoi utilizzare

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aicli
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Antonio Molinari
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -104,6 +118,7 @@ files:
 - lib/aicli/helpers/constants.rb
 - lib/aicli/helpers/error.rb
 - lib/aicli/helpers/i18n.rb
+- lib/aicli/helpers/llm.rb
 - lib/aicli/helpers/os_detect.rb
 - lib/aicli/helpers/shell_history.rb
 - lib/aicli/helpers/strip_regex_patterns.rb