llms 0.1.0

data/lib/llms/executors/open_ai_compatible_executor.rb

@@ -0,0 +1,209 @@
+require_relative 'base_executor'
+require_relative '../apis/open_ai_compatible_api'
+require_relative '../parsers/open_ai_compatible_chat_response_stream_parser'
+require_relative '../adapters/open_ai_compatible_message_adapter'
+
+module LLMs
+  module Executors
+    class OpenAICompatibleExecutor < BaseExecutor
+
+      def execute_conversation(conversation, &block)
+        if block_given?
+          stream_conversation(conversation) do |handler|
+            handler.on(:text_delta) do |event|
+              yield event.text
+            end
+          end
+        else
+          send_conversation(conversation)
+        end
+      end
+
+      def stream_conversation(conversation)
+        init_new_request(conversation)
+
+        emitter = Stream::EventEmitter.new
+        yield emitter if block_given?
+
+        start_time = Time.now
+        begin
+          http_response, stream_parsed_response = stream_client_request(emitter)
+        rescue StandardError => e
+          @last_error = {'error' => e.message, 'backtrace' => e.backtrace}
+          return nil
+        end
+        execution_time = Time.now - start_time
+
+        if http_response && (http_response['error'] || http_response['errors'])
+          @last_error = http_response
+          return nil
+        end
+
+        response_data = stream_parsed_response || http_response
+
+        @last_received_message_id = LLMs::Adapters::OpenAICompatibleMessageAdapter.find_message_id(response_data)
+        @last_received_message = LLMs::Adapters::OpenAICompatibleMessageAdapter.message_from_api_format(response_data)
+        @last_usage_data = calculate_usage(response_data, execution_time)
+
+        @last_received_message
+      end
+
+      def send_conversation(conversation)
+        init_new_request(conversation)
+
+        start_time = Time.now
+        begin
+          http_response = client_request
+        rescue StandardError => e
+          @last_error = {'error' => e.message, 'backtrace' => e.backtrace}
+          @last_usage_data = nil
+          @last_received_message = nil
+          return nil
+        end
+        execution_time = Time.now - start_time
+
+        if http_response && (http_response['error'] || http_response['errors'])
+          @last_error = http_response
+          return nil
+        end
+
+        @last_received_message_id = LLMs::Adapters::OpenAICompatibleMessageAdapter.find_message_id(http_response)
+        @last_received_message = LLMs::Adapters::OpenAICompatibleMessageAdapter.message_from_api_format(http_response)
+        @last_usage_data = calculate_usage(http_response, execution_time)
+
+        @last_received_message
+      end
+
+      private
+
+      def init_new_request(conversation)
+        @last_sent_message = conversation.last_message
+        @last_received_message_id = nil
+        @last_received_message = nil
+        @last_usage_data = nil
+        @last_error = nil
+
+        # need to flatten array since adapter can return array of messages for tool results
+        @formatted_messages = conversation.messages(include_system_message: true).flat_map do |message|
+          LLMs::Adapters::OpenAICompatibleMessageAdapter.to_api_format(message)
+        end
+
+        @available_tools = conversation.available_tools
+      end
+
+      def client_request
+        params = request_params
+        params[:stream] = false
+        @client.chat_completion(@model_name, @formatted_messages, params)
+      end
+
+      def stream_client_request(emitter)
+        parser = Parsers::OpenAICompatibleChatResponseStreamParser.new(emitter)
+
+        params = request_params(true).merge(stream: Proc.new { |chunk| parser.add_data(chunk) })
+        http_response = @client.chat_completion(@model_name, @formatted_messages, params)
+
+        [http_response, parser.full_response]
+      end
+
+      def request_params(is_stream = false)
+        {temperature: @temperature}.tap do |params|
+
+          if param_ok?(:max_tokens) && @max_tokens
+            params[:max_tokens] = @max_tokens
+          end
+
+          ## Will override max_tokens if both are provided
+          if param_ok?(:max_completion_tokens) && @max_completion_tokens
+            params[:max_completion_tokens] = @max_completion_tokens
+          end
+
+          if @thinking_effort
+            params[:reasoning_effort] = @thinking_effort
+          end
+
+          if @available_tools && @available_tools.any?
+            params[:tools] = tool_schemas
+          end
+
+          if is_stream && param_ok?(:stream_options)
+            params[:stream_options] = {
+              include_usage: true
+            }
+          end
+        end
+      end
+
+      def param_ok?(param_name)
+        !@exclude_params&.find { |param| param.to_s == param_name.to_s }
+      end
+
+      def initialize_client
+        if @base_url.nil? || @base_url.empty?
+          raise "base_url required for OpenAICompatibleExecutor"
+        end
+
+        @client = LLMs::APIs::OpenAICompatibleAPI.new(fetch_api_key, @base_url)
+      end
+
+      def calculate_usage(response, execution_time)
+        input_tokens = nil
+        output_tokens = nil
+        cache_was_written = nil
+        cache_was_read = nil
+        token_counts = {}
+
+        if !response.nil? && usage = response['usage']          
+          input_tokens = 0
+          output_tokens = 0
+          cache_was_read = false
+
+          if pt = usage['prompt_tokens']
+            input_tokens += pt
+            token_counts[:input] = pt
+          end
+
+          if ptd = usage['prompt_tokens_details']
+            if ct = ptd['cached_tokens']
+              if ct > 0
+                cache_was_read = true
+              end
+              token_counts[:cached_input] = ct
+              token_counts[:input] -= ct ## TODO confirm this is correct
+            end
+          end
+          
+          if ct = usage['completion_tokens']
+            output_tokens += ct
+            token_counts[:output] = ct
+          end
+        end
+
+        {
+          input_tokens: input_tokens,
+          output_tokens: output_tokens,
+          cache_was_written: cache_was_written,
+          cache_was_read: cache_was_read,
+          token_details: token_counts,
+          execution_time: execution_time,
+          estimated_cost: calculate_cost(token_counts)
+        }
+      end
+
+      ## TODO move to adapter
+      def tool_schemas
+        @available_tools.map do |tool|
+          {
+            type: 'function',
+            function: {
+              name: tool.tool_schema[:name],
+              description: tool.tool_schema[:description],
+              parameters: tool.tool_schema[:parameters],
+            }
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/llms/executors.rb

@@ -0,0 +1,52 @@
+require_relative 'models'
+require_relative 'executors/base_executor'
+require_relative 'executors/anthropic_executor'
+require_relative 'executors/google_gemini_executor'
+require_relative 'executors/open_ai_compatible_executor'
+require_relative 'executors/hugging_face_executor'
+
+module LLMs
+  module Executors
+
+    def self.instance(**params)
+      model_name = params[:model_name]
+      raise ArgumentError, "No model name provided" if model_name.nil?
+
+      executor_class = nil
+      base_url = nil
+      api_key = params[:api_key]
+      api_key_env_var = params[:api_key_env_var]
+      pricing = params[:pricing]
+      exclude_params = params[:exclude_params]
+
+      if params[:oac_base_url]
+        executor_class = OpenAICompatibleExecutor
+        base_url = params[:oac_base_url]
+        api_key = params[:oac_api_key]
+        api_key_env_var = params[:oac_api_key_env_var]
+      else
+        model = Models.find_model(model_name)
+        raise ArgumentError, "Unknown model: #{model_name}" if model.nil?
+
+        model_name = model.model_name
+        executor_class = LLMs::Executors.const_get(model.provider.executor_class_name)
+        base_url = model.provider.base_url
+        api_key_env_var = model.provider.api_key_env_var
+        pricing = model.pricing
+        exclude_params = model.provider.exclude_params
+      end
+
+      init_params = params.merge(
+        model_name:,
+        base_url:,
+        api_key:,
+        api_key_env_var:,
+        pricing:,
+        exclude_params:
+      )
+
+      executor_class.new(**init_params)
+    end
+
+  end
+end

data/lib/llms/models/model.rb

@@ -0,0 +1,86 @@
+module LLMs
+  module Models
+    class Model
+      attr_reader :model_name, :provider, :pricing, :supports_tools, :supports_vision, :supports_thinking, :enabled
+
+      def initialize(model_name, provider, pricing: nil, supports_tools: nil, supports_vision: nil, supports_thinking: nil, enabled: nil)
+        @model_name = model_name.to_s
+        @provider = provider
+        @pricing = pricing&.transform_keys(&:to_sym)
+        @supports_tools = supports_tools
+        @supports_vision = supports_vision
+        @supports_thinking = supports_thinking
+        @enabled = enabled
+      end
+
+      def full_name
+        "#{@provider.provider_name}:#{@model_name}"
+      end
+
+      def possibly_supports_tools?
+        @provider.possibly_supports_tools? && (@supports_tools != false)
+      end
+
+      def certainly_supports_tools?
+        (
+          @provider.certainly_supports_tools? && (@supports_tools != false)
+        ) || (
+          @provider.possibly_supports_tools? && (@supports_tools == true)
+        )
+      end
+
+      def possibly_supports_vision?
+        @provider.possibly_supports_vision? && (@supports_vision != false)
+      end
+
+      def certainly_supports_vision?
+        (
+          @provider.certainly_supports_vision? && (@supports_vision != false)
+        ) || (
+          @provider.possibly_supports_vision? && (@supports_vision == true)
+        )
+      end
+
+      def possibly_supports_thinking?
+        @provider.possibly_supports_thinking? && (@supports_thinking != false)
+      end
+
+      def certainly_supports_thinking?
+        (
+          @provider.certainly_supports_thinking? && (@supports_thinking != false)
+        ) || (
+          @provider.possibly_supports_thinking? && (@supports_thinking == true)
+        )
+      end
+
+      def is_enabled?
+        @provider.is_enabled? && (@enabled != false)
+      end
+
+      def calculate_cost(input_tokens, output_tokens, cache_read_tokens = 0, cache_write_tokens = 0)
+        return 0.0 if @pricing.empty?
+
+        cost = 0.0
+        
+        if input_tokens && input_tokens > 0 && @pricing[:input]
+          cost += (input_tokens / 1_000_000.0) * @pricing[:input]
+        end
+        
+        if output_tokens && output_tokens > 0 && @pricing[:output]
+          cost += (output_tokens / 1_000_000.0) * @pricing[:output]
+        end
+        
+        if cache_read_tokens && cache_read_tokens > 0 && @pricing[:cache_read]
+          cost += (cache_read_tokens / 1_000_000.0) * @pricing[:cache_read]
+        end
+        
+        if cache_write_tokens && cache_write_tokens > 0 && @pricing[:cache_write]
+          cost += (cache_write_tokens / 1_000_000.0) * @pricing[:cache_write]
+        end
+        
+        cost
+      end
+
+    end
+  end
+end 

data/lib/llms/models/provider.rb

@@ -0,0 +1,48 @@
+module LLMs
+  module Models
+    class Provider
+      attr_reader :provider_name, :executor_class_name, :base_url, :api_key_env_var, :supports_tools, :supports_vision, :supports_thinking, :enabled, :exclude_params
+
+      def initialize(provider_name, executor_class_name, base_url: nil, api_key_env_var: nil, supports_tools: nil, supports_vision: nil, supports_thinking: nil, enabled: nil, exclude_params: nil)
+        @provider_name = provider_name.to_s
+        @executor_class_name = executor_class_name.to_s
+        @base_url = base_url
+        @api_key_env_var = api_key_env_var
+        @supports_tools = supports_tools
+        @supports_vision = supports_vision
+        @supports_thinking = supports_thinking
+        @enabled = enabled
+        @exclude_params = exclude_params
+      end
+
+      def possibly_supports_tools?
+        @supports_tools != false
+      end
+
+      def certainly_supports_tools?
+        @supports_tools == true
+      end
+
+      def possibly_supports_vision?
+        @supports_vision != false
+      end
+
+      def certainly_supports_vision?
+        @supports_vision == true
+      end
+
+      def possibly_supports_thinking?
+        @supports_thinking != false
+      end
+
+      def certainly_supports_thinking?
+        @supports_thinking == true
+      end
+
+      def is_enabled?
+        @enabled != false
+      end
+
+    end
+  end
+end

data/lib/llms/models.rb

@@ -0,0 +1,187 @@
+require 'json'
+require_relative 'models/provider'
+require_relative 'models/model'
+
+module LLMs
+  module Models
+
+    DEFAULT_MODEL = 'claude-sonnet-4-0'
+
+    PROVIDER_REGISTRY = {}
+    PROVIDER_TO_MODEL_REGISTRY = {}
+    MODEL_TO_PROVIDER_REGISTRY = {}
+    ALIAS_REGISTRY = {}
+
+    def self.register_model(provider_name, model_name, pricing: nil, tools: nil, vision: nil, thinking: nil, enabled: nil, aliases: nil)
+      provider = PROVIDER_REGISTRY[provider_name.to_s]
+      raise "Unknown provider: #{provider_name}" unless provider
+
+      model = LLMs::Models::Model.new(
+        model_name,
+        provider,
+        pricing:,
+        supports_tools: tools,
+        supports_vision: vision,
+        supports_thinking: thinking,
+        enabled: enabled
+      )
+
+      PROVIDER_TO_MODEL_REGISTRY[provider.provider_name] ||= {}
+      PROVIDER_TO_MODEL_REGISTRY[provider.provider_name][model.model_name] = model
+
+      MODEL_TO_PROVIDER_REGISTRY[model.model_name] ||= Set.new
+      MODEL_TO_PROVIDER_REGISTRY[model.model_name] << provider.provider_name
+
+      if aliases
+        aliases.each do |alias_name|
+          if aliased_model_name = ALIAS_REGISTRY[alias_name]
+            raise "Alias #{alias_name} already registered for #{aliased_model_name}"
+          end
+          ALIAS_REGISTRY[alias_name] = model.model_name
+        end
+      end
+
+      model
+    end
+
+    def self.register_provider(provider_name, executor_class_name, base_url: nil, api_key_env_var: nil, tools: nil, vision: nil, thinking: nil, enabled: nil, exclude_params: nil)
+      provider = LLMs::Models::Provider.new(
+        provider_name,
+        executor_class_name,
+        base_url:,
+        api_key_env_var:,
+        supports_tools: tools,
+        supports_vision: vision,
+        supports_thinking: thinking,
+        enabled:,
+        exclude_params:
+      )
+
+      PROVIDER_REGISTRY[provider.provider_name] = provider
+    end
+
+    def self.disable_model(provider_name, model_name)
+      provider = PROVIDER_REGISTRY[provider_name.to_s]
+      raise "Unknown provider: #{provider_name}" unless provider
+
+      model = PROVIDER_TO_MODEL_REGISTRY[provider.provider_name][model_name]
+      raise "Unknown model: #{model_name}" unless model
+
+      model.enabled = false
+    end
+
+    def self.enable_model(provider_name, model_name)
+      provider = PROVIDER_REGISTRY[provider_name.to_s]
+      raise "Unknown provider: #{provider_name}" unless provider
+
+      model = PROVIDER_TO_MODEL_REGISTRY[provider.provider_name][model_name]
+      raise "Unknown model: #{model_name}" unless model
+
+      model.enabled = true
+    end
+
+    def self.disable_provider(provider_name)
+      provider = PROVIDER_REGISTRY[provider_name.to_s]
+      raise "Unknown provider: #{provider_name}" unless provider
+
+      provider.enabled = false
+    end
+
+    def self.enable_provider(provider_name)
+      provider = PROVIDER_REGISTRY[provider_name.to_s]
+      raise "Unknown provider: #{provider_name}" unless provider
+
+      provider.enabled = true
+    end
+
+    def self.add_model(provider_name, model_name, **details)
+      executor_class_name = details[:executor]
+      provider = register_provider(
+        provider_name, executor_class_name,
+        **details.slice(:base_url, :api_key_env_var, :exclude_params)
+      )
+      register_model(
+        provider.provider_name, model_name,
+        **details.slice(:pricing, :tools, :vision, :thinking, :enabled, :aliases)
+      )
+    end
+
+    def self.load_models_file(file_path)
+      JSON.parse(File.read(file_path)).each do |provider_name, info|
+        executor_class_name = info['executor']
+        params = info.slice('base_url', 'api_key_env_var', 'tools', 'vision', 'thinking', 'enabled', 'exclude_params').transform_keys(&:to_sym)
+        register_provider(provider_name, executor_class_name, **params)
+
+        info['models'].each do |model_name, model_info|
+          params = model_info.slice('pricing', 'tools', 'vision', 'thinking', 'enabled', 'aliases').transform_keys(&:to_sym)
+          register_model(provider_name, model_name, **params)
+        end
+      end
+    end
+
+    load_models_file(File.join(File.dirname(__FILE__), 'public_models.json'))
+
+    def self.find_model(model_name, include_disabled = false)
+      lookup_model_name = (ALIAS_REGISTRY[model_name] || model_name).to_s
+
+      candidate_providers = MODEL_TO_PROVIDER_REGISTRY[lookup_model_name].to_a
+
+      if 1 == candidate_providers.size
+        find_model_for_provider(candidate_providers[0], lookup_model_name, include_disabled)
+      elsif candidate_providers.size > 1
+        raise "Multiple providers match #{model_name}: #{candidate_providers.join(', ')}"
+      else
+        if model_name.include?(':')
+          provider_part, model_name_part = model_name.split(':', 2)
+          find_model_for_provider(provider_part, model_name_part, include_disabled)
+        else
+          nil
+        end
+      end
+    end
+
+    def self.find_model_for_provider(provider_name, model_name, include_disabled = false)
+      provider = PROVIDER_REGISTRY[provider_name.to_s]
+      raise "Unknown provider: #{provider_name}" unless provider
+
+      return nil unless provider.is_enabled? || include_disabled
+
+      model = PROVIDER_TO_MODEL_REGISTRY[provider.provider_name][model_name]
+      if !model.nil? && (model.is_enabled? || include_disabled)
+        model
+      else
+        nil
+      end
+    end
+
+    def self.list_model_names(full: true, require_tools: false, require_vision: false, require_thinking: false, include_disabled: false)
+      ok_model_names = []
+      PROVIDER_REGISTRY.each do |provider_name, provider|
+        provider_ok_for_enabled = include_disabled || provider.is_enabled?
+        provider_ok_for_tools = !require_tools || provider.possibly_supports_tools?
+        provider_ok_for_vision = !require_vision || provider.possibly_supports_vision?
+        provider_ok_for_thinking = !require_thinking || provider.possibly_supports_thinking?
+
+        if provider_ok_for_enabled && provider_ok_for_tools && provider_ok_for_vision && provider_ok_for_thinking
+          PROVIDER_TO_MODEL_REGISTRY[provider.provider_name].each do |_, model|
+            model_ok_for_enabled = include_disabled || model.is_enabled?
+            model_ok_for_tools = !require_tools || (model.certainly_supports_tools?)
+            model_ok_for_vision = !require_vision || (model.certainly_supports_vision?)
+            model_ok_for_thinking = !require_thinking || (model.certainly_supports_thinking?)
+
+            if model_ok_for_enabled && model_ok_for_tools && model_ok_for_vision && model_ok_for_thinking
+              if full
+                ok_model_names << "#{provider_name}:#{model.model_name}"
+              else
+                ok_model_names << model.model_name
+              end
+            end
+          end
+        end
+      end
+
+      ok_model_names.sort
+    end
+
+  end
+end