litellm 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1dd4997378f275e63183ff9dad3c067f78937094193f9caa7524a9d81e11f8f7
+  data.tar.gz: b4ce66a0b829c04c0c7a0a797b38f310c980fb25bac1c2aacb5c032b03df1bc1
+SHA512:
+  metadata.gz: 2af4c2ab3c5b56179738e794db8a74e54e8889feab46a0c1f1d026a2adb0bc5b6145955b6c3a96db36881c39bc6c4a1a429e6417a13e86f1893bc750e91e3ffa
+  data.tar.gz: 28b9ffdd35c4709fec7fcec727a00685727a0ce4ac332966928c47f9e4a89b78f817181c1357ee84b8c4dbf3a0813b28497a947155dfa110fe27b60a88d458ca

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 1.0.0.rc1 (2025-03-08)
+
+- Feature - Initial preview release of the `litellm` ruby gem.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Alex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/VERSION

@@ -0,0 +1 @@
+1.0.0.rc1

data/lib/litellm/client.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module LiteLLM
+  class Client
+    Error = Class.new(StandardError)
+    ConfigurationError = Class.new(Error)
+    ConnectionError = Class.new(Error)
+    TimeoutError = Class.new(Error)
+    APIError = Class.new(Error)
+
+    # @param config [LiteLLM::Config] Configuration object
+    def initialize(config = LiteLLM.configuration)
+      @config = config
+      @messages = []
+
+      validate_configuration!
+    end
+
+    # Make a completion request
+    # @param messages [Array<Hash>] Array of message objects
+    # @param model [String, nil] Optional model override
+    # @param stream [Boolean] Whether to stream the response
+    # @param tools [Array<ToolDefinition>] Array of tools available for the request
+    # @return [Hash, Enumerator] Response data or stream
+    def completion(messages:, model: nil, stream: false, tools: [], system_message: nil, **options,
+                   &block)
+      @messages = messages.dup
+      @messages = [{ role: "system", content: system_message }] + @messages if system_message
+
+      payload = build_payload(
+        messages: @messages,
+        model: model || @config.model,
+        stream: stream,
+        **options
+      )
+
+      payload[:tools] = build_tools_schema(tools) unless tools.empty?
+
+      if stream
+        raise ArgumentError, "Block required for streaming requests" unless block_given?
+
+        stream_completion(payload, tools, model, &block)
+      else
+        non_stream_completion(payload, tools, model)
+      end
+    end
+
+    # Generate embeddings for input text
+    # @param input [String, Array<String>] Input text(s)
+    # @param model [String, nil] Optional model override
+    # @param options [Hash] Additional options to pass to the API
+    # @return [Hash] Embedding response
+    def embedding(input:, model: nil, dimensions: nil, **options)
+      payload = build_payload(
+        input: input,
+        model: model || @config.embedding_model,
+        dimensions: dimensions || @config.embedding_dimensions,
+        **options
+      )
+
+      response = make_request("/embeddings", payload)
+
+      handle_json_response(response).dig("data", 0, "embedding")
+    end
+
+    # Generate images from a prompt
+    # @param prompt [String] Image generation prompt
+    # @param options [Hash] Additional options to pass to the API
+    # @return [Hash] Image generation response
+    def image_generation(prompt:, model: nil, **options)
+      payload = build_payload(
+        prompt: prompt,
+        model: model || @config.image_model,
+        **options
+      )
+
+      response = make_request("/images/generations", payload)
+
+      handle_json_response(response).dig("data", 0, "url")
+    end
+
+    private
+
+    def stream_completion(payload, tools, model, &block)
+      LiteLLM.logger.debug "Starting streaming completion request"
+
+      make_request("/chat/completions", payload) do |content, tool_call_payload|
+        if content
+          block.call(content)
+        elsif tool_call_payload
+          handle_tool_calls(tool_call_payload, tools, model, true, &block)
+        end
+      end
+
+      LiteLLM.logger.debug "Completed streaming request"
+    end
+
+    def non_stream_completion(payload, tools, model)
+      response = make_request("/chat/completions", payload)
+      response = handle_json_response(response, "/chat/completions")
+
+      tool_calls = response.dig("choices", 0, "message", "tool_calls")
+
+      if tool_calls&.any?
+        LiteLLM.logger.debug "Tool calls detected in non-streaming response"
+        handle_tool_calls(response, tools, model, false)
+      else
+        response.dig("choices", 0, "message", "content")
+      end
+    end
+
+    def build_payload(**params)
+      params = params
+               .transform_keys(&:to_sym)
+               .compact
+
+      LiteLLM.logger.debug "--------------------------------"
+      LiteLLM.logger.debug "LiteLLM Request: #{params.to_json}"
+      LiteLLM.logger.debug "--------------------------------"
+
+      params
+    end
+
+    def build_tools_schema(tools)
+      tools.flat_map do |tool|
+        unless tool.is_a?(Module) || tool.respond_to?(:to_tool_format)
+          raise ArgumentError, "Tool must include ToolDefinition module"
+        end
+
+        tool.to_tool_format
+      end
+    end
+
+    def make_request(endpoint, payload, &block)
+      request_id = SecureRandom.uuid
+      log_request(request_id, endpoint, payload)
+
+      response = connection.post(endpoint) do |req|
+        req.headers["X-Request-ID"] = request_id
+        req.body = payload.to_json
+        req.options.on_data = Streaming.process_stream(&block) if payload[:stream]
+      end
+
+      log_response(request_id, response)
+      response
+    rescue StandardError => e
+      log_error(request_id, e)
+      raise
+    end
+
+    def handle_tool_calls(response_data, tools, model, stream, &block)
+      LiteLLM.logger.debug "Handling tool calls, stream=#{stream}"
+
+      begin
+        LiteLLM.logger.debug "Tool call response: #{response_data.inspect}"
+
+        # Add tool-related messages to conversation history
+        tool_messages = ToolHandler.call(response: response_data, available_tools: tools)
+        @messages += tool_messages
+
+        LiteLLM.logger.debug "Tool handler generated messages: #{@messages.inspect}"
+
+        completion(messages: @messages, model: model, tools: tools, stream: stream, &block)
+      rescue StandardError => e
+        LiteLLM.logger.error "Error in handle_tool_calls: #{e.message}\n#{e.backtrace.join("\n")}"
+        raise
+      end
+    end
+
+    def handle_json_response(response, endpoint = nil)
+      LiteLLM.logger.debug <<~LOG
+        --------------------------------
+        LiteLLM RAW Response: #{response.inspect}
+        --------------------------------
+      LOG
+
+      parsed_response = ErrorHandler.parse_json(response.body)
+
+      ErrorHandler.validate_completion_response(parsed_response) if endpoint == "/chat/completions"
+
+      parsed_response
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: @config.base_url) do |f|
+        f.request :json
+        f.response :raise_error
+
+        f.headers["X-LITELLM-TIMEOUT"] = @config.timeout.to_s
+
+        f.headers["Authorization"] = "Bearer #{@config.api_key}" if @config.api_key
+
+        f.headers["X-LITELLM-ENABLE-MESSAGE-REDACTION"] = true if @config.enable_message_redaction
+
+        f.options.timeout = @config.timeout
+        f.adapter Faraday.default_adapter
+      end
+    rescue URI::InvalidURIError => e
+      ErrorHandler.handle_error(
+        ConfigurationError,
+        "Invalid base URL: #{@config.base_url}",
+        e,
+        debug: @config.debug
+      )
+    end
+
+    def validate_configuration!
+      raise ConfigurationError, "Base URL is required" if @config.base_url.nil?
+
+      validate_base_url!
+    end
+
+    def validate_base_url!
+      uri = URI.parse(@config.base_url)
+      unless uri.scheme&.match?(/\Ahttps?\z/)
+        raise ConfigurationError, "Base URL must be HTTP or HTTPS"
+      end
+    rescue URI::InvalidURIError => e
+      raise ConfigurationError, "Invalid base URL: #{e.message}"
+    end
+
+    def log_request(request_id, endpoint, payload)
+      LiteLLM.logger.info("[#{request_id}] Request to #{endpoint}")
+      return unless LiteLLM.configuration.debug
+
+      LiteLLM.logger.debug("[#{request_id}] Payload: #{payload.inspect}")
+    end
+
+    def log_response(request_id, response)
+      LiteLLM.logger.info("[#{request_id}] Response received")
+      return unless LiteLLM.configuration.debug
+
+      LiteLLM.logger.debug("[#{request_id}] Response: #{response.inspect}")
+    end
+
+    def log_error(request_id, e)
+      LiteLLM.logger.error("[#{request_id}] Error: #{e.message}")
+      return unless LiteLLM.configuration.debug
+
+      LiteLLM.logger.debug("[#{request_id}] Backtrace: #{e.backtrace.join("\n")}")
+    end
+  end
+end

data/lib/litellm/configuration.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module LiteLLM
+  DEFAULTS = {
+    base_url: "http://localhost:8000",
+    timeout: 120,
+    model: "gpt-4o",
+    embedding_model: "text-embedding-3-large",
+    image_model: "dall-e-2",
+    embedding_dimensions: 1536,
+    enable_message_redaction: false,
+    debug: false,
+    api_key: ENV.fetch("LITE_LLM_API_KEY", nil)
+  }.freeze
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def logger
+      configuration.logger
+    end
+  end
+
+  class Configuration
+    attr_reader :base_url, :timeout, :model, :embedding_model, :image_model, :embedding_dimensions,
+                :debug, :logger, :enable_message_redaction, :api_key
+
+    def initialize
+      @base_url = DEFAULTS[:base_url]
+      @timeout = DEFAULTS[:timeout]
+      @model = DEFAULTS[:model]
+      @embedding_model = DEFAULTS[:embedding_model]
+      @image_model = DEFAULTS[:image_model]
+      @embedding_dimensions = DEFAULTS[:embedding_dimensions]
+      @enable_message_redaction = DEFAULTS[:enable_message_redaction]
+      @debug = DEFAULTS[:debug]
+      @api_key = DEFAULTS[:api_key]
+      @logger = setup_default_logger
+    end
+
+    def base_url=(value)
+      @base_url = value unless value.nil?
+    end
+
+    def timeout=(value)
+      @timeout = value.to_i unless value.nil?
+    end
+
+    def model=(value)
+      @model = value unless value.nil?
+    end
+
+    def embedding_model=(value)
+      @embedding_model = value unless value.nil?
+    end
+
+    def image_model=(value)
+      @image_model = value unless value.nil?
+    end
+
+    def enable_message_redaction=(value)
+      @enable_message_redaction = value unless value.nil?
+    end
+
+    def api_key=(value)
+      @api_key = value unless value.nil?
+    end
+
+    def debug=(value)
+      @debug = if value.nil?
+                 defined?(Rails) ? Rails.env.development? : false
+               else
+                 value.to_s == "true"
+               end
+    end
+
+    def logger=(value)
+      @logger = value if value
+    end
+
+    private
+
+    def setup_default_logger
+      logger = defined?(Rails) ? Rails.logger : Logger.new($stdout)
+      logger.level = debug ? Logger::DEBUG : Logger::INFO
+      logger
+    end
+  end
+end

data/lib/litellm/errors.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module LiteLLM
+  class BaseError < StandardError
+    attr_reader :original_error
+
+    def initialize(message = nil, original_error = nil)
+      super(message)
+      @original_error = original_error
+    end
+
+    def set_debug_backtrace(debug_mode)
+      return unless @original_error
+
+      set_backtrace(
+        debug_mode ? @original_error.backtrace : [@original_error.backtrace.first]
+      )
+    end
+  end
+
+  class ConfigurationError < BaseError; end
+  class APIError < BaseError; end
+  class TimeoutError < BaseError; end
+  class ConnectionError < BaseError; end
+  class ToolCallError < BaseError; end
+  class InsufficientQuotaError < APIError; end
+  class RateLimitError < APIError; end
+  class AuthenticationError < APIError; end
+  class ValidationError < APIError; end
+
+  module ErrorHandler
+    def self.handle_error(error_class, message, original_error = nil)
+      error = error_class.new(message, original_error)
+      error.set_debug_backtrace(LiteLLM.debug?)
+      raise error
+    end
+
+    def self.handle_api_error(error)
+      error_body = begin
+        parse_json(error.response[:body])
+      rescue StandardError
+        nil
+      end
+      error_message = error_body&.dig("error", "message") || error.message
+
+      case error.response[:status]
+      when 401
+        handle_error(AuthenticationError, "Authentication failed: #{error_message}", error)
+      when 422
+        handle_error(ValidationError, "Validation failed: #{error_message}", error)
+      when 429
+        if error_body&.dig("error", "type") == "insufficient_quota"
+          handle_error(InsufficientQuotaError, "API quota exceeded", error)
+        else
+          handle_error(RateLimitError, "Rate limit exceeded", error)
+        end
+      else
+        handle_error(APIError, "API request failed (#{error.response[:status]}): #{error_message}",
+                     error)
+      end
+    end
+
+    def self.validate_completion_response(response)
+      return if response["choices"]&.first&.dig("message")
+
+      raise APIError, "Invalid response format from server"
+    end
+
+    def self.configuration_error_message(api_key, base_url)
+      [
+        ("API key not configured" if api_key.nil?),
+        ("Base URL not configured" if base_url.nil?)
+      ].compact.join(" and ")
+    end
+
+    def self.handle_tool_error(message, original_error = nil)
+      error = ToolCallError.new(message, original_error)
+      error.set_debug_backtrace(LiteLLM.debug?)
+      raise error
+    end
+
+    private
+
+    def self.parse_json(body)
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      handle_error(APIError, "Invalid JSON response from server: #{e.message}", e)
+    end
+
+    def self.log_debug_response(response)
+      <<~LOG
+        --------------------------------
+        LiteLLM RAW Response: #{response.inspect}
+        --------------------------------
+      LOG
+    end
+  end
+end

data/lib/litellm/streaming.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module LiteLLM
+  module Streaming
+    class StreamingError < StandardError; end
+
+    class StreamBuffer
+      attr_reader :content
+
+      def initialize
+        @content = ""
+        @tool_calls = {}
+        @tool_call_id = nil
+      end
+
+      def add_chunk(parsed_chunk)
+        delta = parsed_chunk.dig("choices", 0, "delta")
+        return process_content(delta) if delta&.key?("content")
+        return process_tool_call(delta) if delta&.key?("tool_calls")
+
+        nil
+      end
+
+      def tool_calls?
+        @tool_calls.any?
+      end
+
+      def tool_call_payload
+        return nil unless tool_calls?
+
+        # Format the response to match standard API response format
+        {
+          "choices" => [
+            {
+              "message" => {
+                "tool_calls" => format_tool_calls
+              }
+            }
+          ]
+        }
+      end
+
+      def reset_tool_call_id
+        @tool_call_id = nil
+      end
+
+      private
+
+      def format_tool_calls
+        @tool_calls.values.map do |call|
+          {
+            "id" => call[:id],
+            "type" => call[:type] || "function",
+            "function" => {
+              "name" => call[:function_name],
+              "arguments" => call[:arguments]
+            }
+          }
+        end
+      end
+
+      def process_content(delta)
+        content = delta["content"].to_s
+        @content += content
+        content
+      end
+
+      def process_tool_call(delta)
+        delta["tool_calls"].each do |tool_call|
+          extract_tool_call_to_buffer(tool_call)
+        end
+        nil
+      end
+
+      def extract_tool_call_to_buffer(tool_call)
+        @tool_call_id = tool_call["id"] if tool_call["id"]
+
+        return unless @tool_call_id
+
+        @tool_calls[@tool_call_id] ||= {
+          id: @tool_call_id,
+          index: tool_call["index"],
+          function_name: nil,
+          type: tool_call["type"],
+          arguments: ""
+        }
+
+        if (type = tool_call["type"])
+          @tool_calls[@tool_call_id][:type] = type
+        end
+
+        if (function_name = tool_call.dig("function", "name"))
+          @tool_calls[@tool_call_id][:function_name] = function_name
+        end
+
+        if (new_arguments = tool_call.dig("function", "arguments"))
+          @tool_calls[@tool_call_id][:arguments] += new_arguments.to_s
+        end
+      end
+    end
+
+    class << self
+      def process_stream(&block)
+        return proc {} unless block
+
+        parser = EventStreamParser::Parser.new
+        buffer = StreamBuffer.new
+
+        proc do |chunk|
+          parser.feed(chunk) do |_type, data|
+            if data.strip == "[DONE]"
+              handle_done(buffer, &block)
+              next
+            end
+
+            process_chunk(data, buffer, &block)
+          end
+        end
+      rescue StandardError => e
+        log_error("Stream Processing Failed", e)
+        raise StreamingError, "Failed to process stream: #{e.message}"
+      end
+
+      private
+
+      def process_chunk(data, buffer, &block)
+        parsed_data = JSON.parse(data)
+        log_debug("Received chunk: #{data}")
+
+        if content = buffer.add_chunk(parsed_data)
+          block.call(content, nil)
+        end
+      rescue JSON::ParserError => e
+        log_error("Stream Chunk Parsing Failed", e, data: data)
+      end
+
+      def handle_done(buffer, &block)
+        return unless buffer.tool_calls?
+
+        tool_calls_response = buffer.tool_call_payload
+        log_debug("Tool call payload: #{tool_calls_response.inspect}")
+
+        block.call(nil, tool_calls_response)
+        buffer.reset_tool_call_id
+      end
+
+      def log_debug(message)
+        LiteLLM.logger.debug("[Streaming] #{message}")
+      end
+
+      def log_error(message, error, **context)
+        LiteLLM.logger.error("[Streaming] #{message}", error: error, **context)
+      end
+    end
+  end
+end

data/lib/litellm/tool_handler.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module LiteLLM
+  module ToolHandler
+    class ToolCallError < BaseError; end
+
+    def self.call(response:, available_tools: [])
+      tool_calls = response.dig("choices", 0, "message", "tool_calls")
+      return response unless tool_calls&.any?
+
+      # Build a mapping of function names to tools
+      @available_tools = {}
+      available_tools.each do |tool|
+        tool.class.function_definitions.each do |function_name, definition|
+          @available_tools[definition[:name]] = tool
+        end
+      end
+
+      LiteLLM.logger.debug "Available tool functions: #{@available_tools.keys.inspect}"
+
+      messages = [
+        response.dig("choices", 0, "message").merge("role" => "assistant")
+      ]
+
+      tool_results = execute_tool_calls(tool_calls)
+      messages.concat(build_tool_messages(tool_results))
+
+      messages
+    end
+
+    private
+
+    def self.execute_tool_calls(tool_calls)
+      tool_calls.map do |tool_call|
+        function_name = tool_call.dig("function", "name")
+        arguments = parse_tool_arguments(tool_call.dig("function", "arguments"))
+
+        tool = @available_tools[function_name]
+
+        unless tool
+          raise ToolCallError,
+                "Tool function '#{function_name}' not available for this request: DEBUG: #{@available_tools.inspect}"
+        end
+
+        output = tool.execute_function(function_name, arguments)
+
+        LiteLLM.logger.info "Tool call executed: #{function_name} with arguments: #{arguments.inspect}, output: #{output.inspect}"
+
+        {
+          tool_call_id: tool_call["id"],
+          function_name: function_name,
+          output: output
+        }
+      rescue StandardError => e
+        handle_tool_execution_error(tool_call, e)
+      end
+    end
+
+    def self.parse_tool_arguments(arguments_json)
+      return {} if arguments_json.nil? || arguments_json.empty?
+
+      JSON.parse(arguments_json).transform_keys(&:to_sym)
+    rescue JSON::ParserError => e
+      raise ToolCallError.new("Invalid tool call arguments: #{e.message}", e)
+    end
+
+    def self.build_tool_messages(results)
+      results.map do |result|
+        {
+          "role" => "tool",
+          "tool_call_id" => result[:tool_call_id],
+          "name" => result[:function_name],
+          "content" => result[:output].to_s
+        }
+      end
+    end
+
+    def self.handle_tool_execution_error(tool_call, error)
+      function_name = tool_call.dig("function", "name")
+      arguments = tool_call.dig("function", "arguments")
+
+      LiteLLM.logger.error "Tool call failed: #{function_name} with arguments: #{arguments.inspect}"
+      LiteLLM.logger.error "Error details: #{error.class} - #{error.message}"
+      LiteLLM.logger.error error.backtrace.join("\n") if error.backtrace
+
+      {
+        tool_call_id: tool_call["id"],
+        function_name: function_name,
+        output: "Error executing tool: #{error.message}"
+      }
+    end
+  end
+end

data/lib/litellm/utils/tool_definition.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LiteLLM
+  module Utils
+    module ToolDefinition
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def define_function(method_name, description:, &block)
+          function_definitions[method_name] = {
+            name: "#{normalized_tool_name}__#{method_name}",
+            description: description,
+            parameters: build_parameters(&block)
+          }
+        end
+
+        def function_definitions
+          @function_definitions ||= {}
+        end
+
+        def normalized_tool_name
+          @normalized_tool_name ||= name.split("::").last.gsub(/Tool\z/, "")
+        end
+
+        private
+
+        def build_parameters(&block)
+          return nil unless block_given?
+
+          builder = ParameterBuilder.new
+          schema = builder.build(&block)
+
+          {
+            type: "object",
+            properties: schema[:properties],
+            required: schema[:required],
+            additionalProperties: false
+          }
+        end
+      end
+
+      def to_tool_format
+        self.class.function_definitions.values.map do |function|
+          { type: "function", function: function }
+        end
+      end
+
+      def execute_function(function_name, parameters = {})
+        method_name = function_name.to_s.split("__").last
+        log_prefix = "[#{self.class.name}##{method_name}]"
+
+        LiteLLM.logger.info("#{log_prefix} Called with parameters: #{parameters.inspect}")
+
+        unless respond_to?(method_name, true)
+          error_message = "Function '#{method_name}' not found in #{self.class.name}"
+          LiteLLM.logger.error("#{log_prefix} #{error_message}")
+          raise NoMethodError, error_message
+        end
+
+        begin
+          symbolized_params = parameters.transform_keys(&:to_sym)
+          validate_parameters(method_name, symbolized_params)
+
+          result = send(method_name, **symbolized_params)
+
+          LiteLLM.logger.info("#{log_prefix} Execution successful, returned: #{result.inspect}")
+          result
+        rescue ArgumentError => e
+          LiteLLM.logger.error("#{log_prefix} Parameter validation failed: #{e.message}")
+          raise
+        rescue StandardError => e
+          LiteLLM.logger.error("#{log_prefix} Execution failed: #{e.class} - #{e.message}")
+          LiteLLM.logger.error("#{log_prefix} Backtrace: #{e.backtrace.first(5).join("\n")}")
+          raise
+        end
+      end
+
+      private
+
+      def validate_parameters(method_name, params)
+        function_def = self.class.function_definitions[method_name.to_sym]
+        return unless function_def && function_def[:parameters]
+
+        required_params = function_def[:parameters][:required] || []
+        missing_params = required_params - params.keys.map(&:to_s)
+
+        return if missing_params.empty?
+
+        raise ArgumentError, "Missing required parameters: #{missing_params.join(', ')}"
+      end
+
+      class ParameterBuilder
+        VALID_TYPES = %w[object array string number integer boolean null]
+
+        def initialize
+          @properties = {}
+          @required = []
+        end
+
+        def build(&block)
+          instance_eval(&block)
+          { properties: @properties, required: @required }
+        end
+
+        def property(name, type:, description: nil, enum: nil, required: false, default: nil,
+                     &block)
+          validate_property_params(name, type, enum, required)
+
+          prop = {
+            type: type,
+            description: description,
+            enum: enum,
+            default: default
+          }.compact
+
+          if block_given?
+            nested_builder = ParameterBuilder.new
+            nested_schema = nested_builder.build(&block)
+
+            case type
+            when "object"
+              if nested_schema[:properties].empty?
+                raise ArgumentError, "Object properties must have at least one property"
+              end
+
+              prop[:properties] = nested_schema[:properties]
+              prop[:required] = nested_schema[:required] unless nested_schema[:required].empty?
+
+            when "array"
+              if nested_schema[:properties].empty?
+                raise ArgumentError, "Array items must be defined"
+              end
+
+              # For simplicity, use the first property definition as the items schema
+              # This assumes a single item type definition in the block
+              prop[:items] = nested_schema[:properties].values.first
+            end
+          end
+
+          @properties[name] = prop
+          @required << name.to_s if required
+        end
+
+        alias item property
+
+        private
+
+        def validate_property_params(name, type, enum, required)
+          unless name.is_a?(Symbol)
+            raise ArgumentError,
+                  "Name must be a symbol, got: #{name.class}"
+          end
+
+          unless VALID_TYPES.include?(type)
+            raise ArgumentError, "Invalid type '#{type}'. Valid types: #{VALID_TYPES.join(', ')}"
+          end
+
+          unless enum.nil? || enum.is_a?(Array)
+            raise ArgumentError, "Enum must be nil or an array, got: #{enum.class}"
+          end
+
+          return if required.is_a?(TrueClass) || required.is_a?(FalseClass)
+
+          raise ArgumentError, "Required must be boolean, got: #{required.class}"
+        end
+      end
+    end
+  end
+end

data/lib/litellm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LiteLLM
+  VERSION = File.read(File.expand_path("../../VERSION", __dir__)).strip
+end

data/lib/litellm.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'event_stream_parser'
+require 'json'
+require 'logger'
+
+require_relative 'litellm/version'
+require_relative 'litellm/configuration'
+require_relative 'litellm/streaming'
+require_relative 'litellm/client'
+require_relative 'litellm/errors'
+require_relative 'litellm/tool_handler'
+require_relative 'litellm/utils/tool_definition'
+
+module LiteLLM
+  class Error < StandardError; end
+
+  module Utils
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration
+      @configuration = Configuration.new
+    end
+
+    def client
+      @client ||= Client.new
+    end
+
+    def completion(*args)
+      client.completion(*args)
+    end
+
+    def embedding(*args)
+      client.embedding(*args)
+    end
+
+    def image_generation(*args)
+      client.image_generation(*args)
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    def debug?
+      configuration.debug
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: litellm
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Mohamed Nimir
+bindir: bin
+cert_chain: []
+date: 2025-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: event_stream_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+description: A Ruby client for LiteLLM (the LLM proxy/gateway).
+email:
+- mohamed.nimir@eptikar.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- VERSION
+- lib/litellm.rb
+- lib/litellm/client.rb
+- lib/litellm/configuration.rb
+- lib/litellm/errors.rb
+- lib/litellm/streaming.rb
+- lib/litellm/tool_handler.rb
+- lib/litellm/utils/tool_definition.rb
+- lib/litellm/version.rb
+homepage: https://github.com/eptikar/litellm-ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/eptikar/ruby-litellm
+  changelog_uri: https://github.com/eptikar/ruby-litellm/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/eptikar/ruby-litellm/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: LiteLLM Ruby Client.
+test_files: []