llms 0.1.0

data/lib/llms/apis/open_ai_compatible_api.rb

@@ -0,0 +1,54 @@
+require 'net/http'
+require 'json'
+
+module LLMs
+  module APIs
+    class OpenAICompatibleAPI
+      def initialize(api_key, base_url)
+        @api_key = api_key
+        @base_url = base_url
+      end
+
+      def chat_completion(model_name, messages, params = {})
+        uri = URI("#{@base_url}/chat/completions")
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = @base_url.start_with?('https://')
+        http.read_timeout = 1000
+
+        stream = params.delete(:stream)
+        params[:stream] = !!stream
+
+        request = Net::HTTP::Post.new(uri).tap do |req|
+          req['Content-Type'] = 'application/json'
+          req['Authorization'] = "Bearer #{@api_key}"
+          req.body = params.merge({
+            model: model_name,
+            messages: messages,
+          }).to_json
+        end
+
+        if !!stream
+          http.request(request) do |response|
+            if response.code.to_s == '200'
+              response.read_body do |data|
+                stream.call(data)
+              end
+              return nil ## return nil to indicate that there's no separate api response other than the stream
+            else
+              return JSON.parse(response.body)
+            end
+          end
+        else
+          response = http.request(request)
+          if response.code.to_s == '200'
+            JSON.parse(response.body)
+          else
+            {'error' => JSON.parse(response.body)} ## TODO add status code?
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/llms/cli/base.rb

@@ -0,0 +1,186 @@
+require 'optparse'
+
+module LLMs
+  module CLI
+    class Base
+      attr_reader :options, :executor
+
+      def initialize(command_name, override_default_options = {})
+        @command_name = command_name
+        @options = default_options.merge(override_default_options)
+        parse_options
+      end
+
+      def run
+        setup
+        execute
+        cleanup
+      rescue LLMs::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        $stderr.puts "Unexpected error: #{e.message}"
+        if @options[:debug]
+          $stderr.puts e.backtrace
+        end
+        exit 1
+      end
+
+      protected
+
+      def default_options
+        {
+          stream: false,
+          usage: false,
+          quiet: false,
+          debug: false,
+          model_name: nil,
+          list_models: false,
+          max_completion_tokens: nil,
+          max_thinking_tokens: nil,
+          thinking_effort: nil,
+          thinking_mode: false,
+          temperature: 0.0,
+          oac_base_url: nil,
+          oac_api_key: nil,
+          oac_api_key_env_var: nil
+        }
+      end
+
+      def parse_options
+        OptionParser.new do |opts|
+          opts.banner = "Usage: #{@command_name} [options]"
+
+          opts.on("--system PROMPT", "Set custom system prompt") do |prompt|
+            @options[:system_prompt] = prompt
+          end
+
+          opts.on("--stream", "Stream the output") do
+            @options[:stream] = true
+          end
+
+          opts.on("--usage", "Show usage information") do
+            @options[:usage] = true
+          end
+
+          opts.on("-q", "--quiet", "Suppress non-essential output") do
+            @options[:quiet] = true
+          end
+
+          opts.on("-d", "--debug", "Enable debug output") do
+            @options[:debug] = true
+          end
+
+          opts.on("-m", "--model MODEL", "Specify model name") do |model|
+            @options[:model_name] = model
+          end
+
+          opts.on("-l", "--list-models", "List available models") do
+            @options[:list_models] = true
+          end
+
+          opts.on("--max-completion-tokens N", Integer, "Set max completion tokens") do |n|
+            @options[:max_completion_tokens] = n
+          end
+
+          opts.on("--max-thinking-tokens N", Integer, "Set max thinking tokens") do |n|
+            @options[:max_thinking_tokens] = n
+          end
+
+          opts.on("--thinking-effort L", "Set thinking effort (low, medium, high)") do |level|
+            @options[:thinking_effort] = level
+          end
+
+          opts.on("-t", "--thinking", "Enable thinking mode") do
+            @options[:thinking_mode] = true
+          end
+
+          opts.on("--temperature T", Float, "Set temperature") do |t|
+            @options[:temperature] = t
+          end
+
+          opts.on("--oac-base-url URL", "OpenAI Compatible base URL to use") do |url|
+            @options[:oac_base_url] = url
+          end
+
+          opts.on("--oac-api-key KEY", "OpenAI Compatible API key to use") do |key|
+            @options[:oac_api_key] = key
+          end
+
+          opts.on("--oac-api-key-env-var VAR", "OpenAI Compatible API key environment variable to use") do |var|
+            @options[:oac_api_key_env_var] = var
+          end
+
+          add_custom_options(opts)
+        end.parse!
+      end
+
+      def add_custom_options(opts)
+        # Override in subclasses to add custom options
+      end
+
+      def setup
+        validate_options
+        set_executor unless @options[:list_models]
+      end
+
+      def execute
+        if @options[:list_models]
+          list_models
+        else
+          perform_execution
+        end
+      end
+
+      def cleanup
+        # Override in subclasses if needed
+      end
+
+      def validate_options
+        raise LLMs::ConfigurationError, "Model name is required" if @options[:model_name].nil? && !@options[:list_models]
+      end
+
+      def set_executor
+        @executor = create_executor
+      end
+
+      def create_executor(options_override = {})
+        executor = LLMs::Executors.instance(**@options.merge(options_override))
+
+        unless @options.merge(options_override)[:quiet]
+          puts "Connected to: #{executor.model_name} (#{executor.class.name}#{executor.base_url ? " #{executor.base_url}" : ""})"
+        end
+
+        executor
+      end
+
+      def list_models
+        models = LLMs::Models.list_model_names(full: true)
+        if @options[:model]
+          models = models.select { |name| name.include?(@options[:model]) }
+        end
+        puts models
+      end
+
+      def perform_execution
+        raise NotImplementedError, "Subclasses must implement perform_execution"
+      end
+
+      def report_usage(executor)
+        return if @options[:quiet] || !@options[:usage]
+
+        if usage = executor.last_usage_data
+          puts usage.inspect
+        end
+      end
+
+      def report_error(executor)
+        return if @options[:quiet]
+
+        if error = executor.last_error
+          $stderr.puts "Error: #{error.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/llms/cli/chat.rb

@@ -0,0 +1,92 @@
+require_relative 'base'
+require 'readline'
+
+module LLMs
+  module CLI
+    class Chat < Base
+      protected
+
+      def default_options
+        super.merge({
+          stream: true,
+          system_prompt: "You are a helpful assistant",
+          model_name: LLMs::Models::DEFAULT_MODEL,
+          max_completion_tokens: 2048,
+          thinking_mode: false,
+          thinking_effort: nil,
+          max_thinking_tokens: 1024,
+          quiet: false
+        })
+      end
+
+      def add_custom_options(opts)
+        opts.on("--no-stream", "Disable streaming output") do
+          @options[:stream] = false
+        end
+        opts.on("--system PROMPT", "Set custom system prompt") do |prompt|
+          @options[:system_prompt] = prompt
+        end
+      end
+
+      def perform_execution
+        if ARGV.empty?
+          run_chat
+        else
+          run_prompt(ARGV.join(' '))
+        end
+      end
+
+      private
+
+      def run_chat
+        conversation = LLMs::Conversation.new
+        conversation.set_system_message(@options[:system_prompt])
+
+        Readline.completion_append_character = " "
+        Readline.completion_proc = proc { |s| [] }
+
+        loop do
+          prompt = Readline.readline("> ", true)
+          break if prompt.nil? || prompt.empty? || prompt == "exit"
+
+          conversation.add_user_message(prompt)
+
+          if @options[:stream]
+            @executor.execute_conversation(conversation) { |chunk| print chunk }
+            puts
+          else
+            response = @executor.execute_conversation(conversation)
+            puts response.text
+          end
+
+          if error = @executor.last_error
+            $stderr.puts "Error: #{error.inspect}"
+          end
+
+          unless @options[:quiet]
+            usage = @executor.last_usage_data
+            puts "Usage: #{usage}"
+          end
+
+          conversation.add_assistant_message(@executor.last_received_message)
+        end
+      end
+
+      def run_prompt(prompt)
+        if @options[:stream]
+          @executor.execute_prompt(prompt.strip) { |chunk| print chunk }
+          puts
+        else
+          response = @executor.execute_prompt(prompt.strip)
+          puts response
+        end
+
+        if error = @executor.last_error
+          $stderr.puts "Error: #{error.inspect}"
+        end
+
+        report_usage(executor)
+      end
+    end
+  end
+end

data/lib/llms/cli/test_access.rb

@@ -0,0 +1,79 @@
+require_relative 'base'
+
+module LLMs
+  module CLI
+    class TestAccess < Base
+      protected
+
+      def default_options
+        super.merge({
+          max_completion_tokens: 250,
+          prompt: "2+2=",
+          system_prompt: "Always reply with numbers as WORDS not digits."
+        })
+      end
+
+      def add_custom_options(opts)
+        opts.on("--prompt PROMPT", "Test prompt to use") do |prompt|
+          @options[:prompt] = prompt
+        end
+      end
+
+      def setup
+        # No model name required for this command
+        true
+      end
+
+      def perform_execution
+        if @options[:model_name]
+          test_single_model(create_executor)
+        else
+          test_all_models
+        end
+      end
+
+      private
+
+      def test_single_model(executor)
+        begin
+          if @options[:stream]
+            response = executor.execute_prompt(@options[:prompt], system_prompt: @options[:system_prompt]) do |chunk|
+              print chunk
+            end
+            puts
+          else
+            response = executor.execute_prompt(@options[:prompt], system_prompt: @options[:system_prompt])
+            puts response
+          end
+
+          report_error(executor)
+          report_usage(executor)
+
+        rescue StandardError => e
+          puts "#{executor.model_name}: ERROR - #{e.message}"
+          puts e.backtrace if @options[:debug]
+        end
+      end
+
+      def test_all_models
+        models = get_models_to_test
+
+        models.each do |model_name|
+          test_single_model(create_executor({model_name: model_name}))
+          puts "-" * 80
+        end
+      end
+
+      def get_models_to_test
+        models = LLMs::Models.list_model_names(full: true)
+
+        # Filter by model name if provided
+        if ARGV[0]
+          models = models.select { |name| name.include?(ARGV[0]) }
+        end
+
+        models
+      end
+    end
+  end
+end

data/lib/llms/cli/test_image_support.rb

@@ -0,0 +1,92 @@
+require_relative 'base'
+require 'open-uri'
+require 'base64'
+require_relative '../conversation'
+
+module LLMs
+  module CLI
+    class TestImageSupport < Base
+      protected
+
+      def default_options
+        super.merge({
+          max_completion_tokens: 2000,
+          prompt: "What is in this picture?",
+          system_prompt: "Always reply in Latin"
+        })
+      end
+
+      def add_custom_options(opts)
+        opts.on("--prompt PROMPT", "Test prompt to use") do |prompt|
+          @options[:prompt] = prompt
+        end
+      end
+
+      def setup
+        # No model name required for this command
+        true
+      end
+
+      def perform_execution
+        if @options[:model_name]
+          test_single_model(create_executor)
+        else
+          test_all_models
+        end
+      end
+
+      private
+
+      def test_single_model(executor)
+        begin
+          image_data = fetch_image_data
+
+          cm = LLMs::Conversation.new
+          cm.set_system_message(@options[:system_prompt])
+          cm.add_user_message([{ text: @options[:prompt], image: image_data, media_type: 'image/png' }])
+
+          if @options[:stream]
+            executor.execute_conversation(cm) do |chunk|
+              print chunk
+            end
+            puts
+          else
+            response_message = executor.execute_conversation(cm)
+            puts response_message&.text
+          end
+
+          report_error(executor)
+          report_usage(executor)
+
+        rescue StandardError => e
+          puts "#{executor.model_name}: ERROR - #{e.message}"
+          puts e.backtrace if @options[:debug]
+        end
+      end
+
+      def test_all_models
+        models = get_models_to_test
+
+        models.each do |model_name|
+          test_single_model(create_executor({model_name: model_name}))
+          puts "-" * 80
+        end
+      end
+
+      def get_models_to_test
+        models = LLMs::Models.list_model_names(full: true, require_vision: true)
+
+        # Filter by model name if provided
+        if ARGV[0]
+          models = models.select { |name| name.include?(ARGV[0]) }
+        end
+
+        models
+      end
+
+      def fetch_image_data
+        Base64.strict_encode64(URI.open('https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png').read)
+      end
+    end
+  end
+end