llm_ruby 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfe908817dd406ae16aca4130133b9a421b18333cdecc4ad870635dd997be500
-  data.tar.gz: 105ae0dcc30918686abcf8d01d99605d2f70f41eebdd2737744bc2bf27c6575c
+  metadata.gz: edf2b09bc3a9416193088298e41577369bf5198230c7278d6a832854f04c7e20
+  data.tar.gz: 735c0e1735d90e5c41a93d7e123bfe359c0a3525bf292ba46d0a6b8c23580c05
 SHA512:
-  metadata.gz: 5b9643df8771735111f18f52182b6f217231ca92c890e3456f21c3937850bf2c9ac668730cd1aeae8b43330d5a3c84eab6b419c60aa5d54d70f405793e4463ad
-  data.tar.gz: 820687838675aeaadde8e5b7c5b7f7f45bfdf10beb74b90e2b594cd80d5e7accc38ace2deec56a6a2fcdc3de6a369af41405c5523da3e4c2b47f6e584c28f3fd
+  metadata.gz: d7509110f0f53028e6d6c6cc899ab31985748e2f5775be64286fc1a66659723953fee49f8ea70c1f797e9c7786bf401634d35f201d4b44d0f4abd11a22d691ed
+  data.tar.gz: 447086c9fed992e31db3e0bec1f9a92d0b52995ad899f11e9eeba0674eaf0a734918b4ee144a3b869ba6e61b7f2c73dcba2eaec5b602700d8c126a4de4c0ad33

data/README.md

@@ -1,6 +1,6 @@
 # LLMRuby
 
-LLMRuby is a Ruby gem that provides a consistent interface for interacting with various Large Language Model (LLM) APIs, with a current focus on OpenAI's models.
+LLMRuby is a Ruby gem that provides a consistent interface for interacting with multiple Large Language Model (LLM) APIs. Most OpenAI, Anthropic and Gemini models are currently supported.
 
 ## Installation
 
@@ -12,14 +12,14 @@ gem 'llm_ruby'
 
 And then execute:
 
-```
-$ bundle install
+```shell
+bundle install
 ```
 
 Or install it yourself as:
 
-```
-$ gem install llm_ruby
+```shell
+gem install llm_ruby
 ```
 
 ## Usage
@@ -27,7 +27,7 @@ $ gem install llm_ruby
 ### Basic Usage
 
 ```ruby
-require 'llm'
+require 'llm_ruby'
 
 # Initialize an LLM instance
 llm = LLM.from_string!("gpt-4")
@@ -46,10 +46,10 @@ puts response.content
 LLMRuby supports streaming responses:
 
 ```ruby
-require 'llm'
+require 'llm_ruby'
 
 # Initialize an LLM instance
-llm = LLM.from_string!("gpt-4")
+llm = LLM.from_string!("gpt-4o")
 
 # Create a client
 client = llm.client
@@ -87,7 +87,7 @@ Here is an example of how to use the response object:
 
 ```ruby
 # Initialize an LLM instance
-llm = LLM.from_string!("gpt-4")
+llm = LLM.from_string!("gpt-4o")
 
 # Create a client
 client = llm.client
@@ -101,37 +101,69 @@ puts "Raw response: #{response.raw_response}"
 puts "Stop reason: #{response.stop_reason}"
 ```
 
-
 ## Available Models
 
 LLMRuby supports various OpenAI models, including GPT-3.5 and GPT-4 variants. You can see the full list of supported models in the `KNOWN_MODELS` constant:
 
-| Canonical Name            | Display Name           | Provider |
-|---------------------------|------------------------|----------|
-| gpt-3.5-turbo             | GPT-3.5 Turbo          | openai   |
-| gpt-3.5-turbo-0125        | GPT-3.5 Turbo 0125     | openai   |
-| gpt-3.5-turbo-16k         | GPT-3.5 Turbo 16K      | openai   |
-| gpt-3.5-turbo-1106        | GPT-3.5 Turbo 1106     | openai   |
-| gpt-4                     | GPT-4                  | openai   |
-| gpt-4-32k                 | GPT-4 32K              | openai   |
-| gpt-4-1106-preview        | GPT-4 Turbo 1106       | openai   |
-| gpt-4-turbo-2024-04-09    | GPT-4 Turbo 2024-04-09 | openai   |
-| gpt-4-0125-preview        | GPT-4 Turbo 0125       | openai   |
-| gpt-4-turbo-preview       | GPT-4 Turbo            | openai   |
-| gpt-4-0613                | GPT-4 0613             | openai   |
-| gpt-4-32k-0613            | GPT-4 32K 0613         | openai   |
-| gpt-4o                    | GPT-4o                 | openai   |
-| gpt-4o-mini               | GPT-4o Mini            | openai   |
-| gpt-4o-2024-05-13         | GPT-4o 2024-05-13      | openai   |
-| gpt-4o-2024-08-06         | GPT-4o 2024-08-06      | openai   |
-
+### OpenAI Models
+
+| Canonical Name             | Display Name                         |
+|----------------------------|--------------------------------------|
+| gpt-3.5-turbo              | GPT-3.5 Turbo                        |
+| gpt-3.5-turbo-0125         | GPT-3.5 Turbo 0125                   |
+| gpt-3.5-turbo-16k          | GPT-3.5 Turbo 16K                    |
+| gpt-3.5-turbo-1106         | GPT-3.5 Turbo 1106                   |
+| gpt-4                      | GPT-4                                |
+| gpt-4-1106-preview         | GPT-4 Turbo 1106                     |
+| gpt-4-turbo-2024-04-09     | GPT-4 Turbo 2024-04-09               |
+| gpt-4-0125-preview         | GPT-4 Turbo 0125                     |
+| gpt-4-turbo-preview        | GPT-4 Turbo                          |
+| gpt-4-0613                 | GPT-4 0613                           |
+| gpt-4o                     | GPT-4o                               |
+| gpt-4o-mini                | GPT-4o Mini                          |
+| gpt-4o-mini-2024-07-18     | GPT-4o Mini 2024-07-18               |
+| gpt-4o-2024-05-13          | GPT-4o 2024-05-13                    |
+| gpt-4o-2024-08-06          | GPT-4o 2024-08-06                    |
+| gpt-4o-2024-11-20          | GPT-4o 2024-11-20                    |
+| chatgpt-4o-latest          | ChatGPT 4o Latest                    |
+| o1                         | o1                                   |
+| o1-2024-12-17              | o1 2024-12-17                        |
+| o1-preview                 | o1 Preview                           |
+| o1-preview-2024-09-12      | o1 Preview 2024-09-12                |
+| o1-mini                    | o1 Mini                              |
+| o1-mini-2024-09-12         | o1 Mini 2024-09-12                   |
+| o3-mini                    | o3 Mini                              |
+| o3-mini-2025-01-31         | o3 Mini 2025-01-31                   |
+
+### Anthropic Models
+
+| Canonical Name             | Display Name                         |
+|----------------------------|--------------------------------------|
+| claude-3-5-sonnet-20241022 | Claude 3.5 Sonnet 2024-10-22         |
+| claude-3-5-haiku-20241022  | Claude 3.5 Haiku 2024-10-22          |
+| claude-3-5-sonnet-20240620 | Claude 3.5 Sonnet 2024-06-20         |
+| claude-3-opus-20240229     | Claude 3.5 Opus 2024-02-29           |
+| claude-3-sonnet-20240229   | Claude 3.5 Sonnet 2024-02-29         |
+| claude-3-haiku-20240307    | Claude 3.5 Opus 2024-03-07           |
+
+### Google Models
+
+| Canonical Name                       | Display Name                             |
+|--------------------------------------|------------------------------------------|
+| gemini-2.0-flash                     | Gemini 2.0 Flash                         |
+| gemini-2.0-flash-lite-preview-02-05  | Gemini 2.0 Flash Lite Preview 02-05      |
+| gemini-1.5-flash                     | Gemini 1.5 Flash                         |
+| gemini-1.5-pro                       | Gemini 1.5 Pro                           |
+| gemini-1.5-flash-8b                  | Gemini 1.5 Flash 8B                      |
 
 ## Configuration
 
-Set your OpenAI API key as an environment variable:
+Set your OpenAI, Anthropic or Google API key as an environment variable:
 
-```
+```shell
 export OPENAI_API_KEY=your_api_key_here
+export ANTHROPIC_API_KEY=your_api_key_here
+export GEMINI_API_KEY=your_api_key_here
 ```
 
 ## Development
@@ -142,12 +174,8 @@ To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/contextco/llm_ruby.
+Bug reports and pull requests are welcome.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Acknowledgements
-
-This gem is developed and maintained by [Context](https://context.ai).

data/lib/llm/clients/anthropic/response.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class LLM
+  module Clients
+    class Anthropic
+      class Response
+        def initialize(raw_response)
+          @raw_response = raw_response
+        end
+
+        def to_normalized_response
+          LLM::Response.new(
+            content: content,
+            raw_response: parsed_response,
+            stop_reason: normalize_stop_reason
+          )
+        end
+
+        def self.normalize_stop_reason(stop_reason)
+          case stop_reason
+          when "end_turn"
+            LLM::StopReason::STOP
+          when "stop_sequence"
+            LLM::StopReason::STOP_SEQUENCE
+          when "max_tokens"
+            LLM::StopReason::MAX_TOKENS_REACHED
+          else
+            LLM::StopReason::OTHER
+          end
+        end
+
+        private
+
+        def content
+          parsed_response.dig("content", 0, "text")
+        end
+
+        def normalize_stop_reason
+          self.class.normalize_stop_reason(parsed_response["stop_reason"])
+        end
+
+        def parsed_response
+          @raw_response.parsed_response
+        end
+      end
+    end
+  end
+end

data/lib/llm/clients/anthropic.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+class LLM
+  module Clients
+    class Anthropic
+      include HTTParty
+      base_uri "https://api.anthropic.com"
+
+      def initialize(llm:)
+        @llm = llm
+      end
+
+      def chat(messages, options = {})
+        request = payload(messages, options)
+
+        return chat_streaming(request, options[:on_message], options[:on_complete]) if options[:stream]
+
+        resp = post_url("/v1/messages", body: request.to_json)
+
+        Response.new(resp).to_normalized_response
+      end
+
+      private
+
+      def chat_streaming(request, on_message, on_complete)
+        buffer = +""
+        chunks = []
+        output_data = {}
+
+        wrapped_on_complete = lambda { |stop_reason|
+          output_data[:stop_reason] = stop_reason
+          on_complete&.call(stop_reason)
+        }
+
+        request[:stream] = true
+
+        proc = handle_event_stream(buffer, chunks, on_message_proc: on_message, on_complete_proc: wrapped_on_complete)
+
+        _resp = post_url_streaming("/v1/messages", body: request.to_json, &proc)
+
+        LLM::Response.new(
+          content: buffer,
+          raw_response: chunks,
+          stop_reason: Response.normalize_stop_reason(output_data[:stop_reason])
+        )
+      end
+
+      def handle_event_stream(buffer, chunks, on_message_proc:, on_complete_proc:)
+        each_json_chunk do |type, chunk|
+          chunks << chunk
+          case type
+          when "content_block_delta"
+            new_content = chunk.dig("delta", "text")
+            buffer << new_content
+            on_message_proc&.call(new_content)
+          when "message_delta"
+            finish_reason = chunk.dig("delta", "stop_reason")
+            on_complete_proc&.call(finish_reason)
+          else
+            next
+          end
+        end
+      end
+
+      def each_json_chunk
+        parser = EventStreamParser::Parser.new
+
+        proc do |chunk|
+          # TODO: Add error handling.
+
+          parser.feed(chunk) do |type, data|
+            yield(type, JSON.parse(data))
+          end
+        end
+      end
+
+      def payload(messages, options = {})
+        {
+          system: combined_system_messages(messages),
+          messages: messages.filter { |m| m[:role].to_sym != :system },
+          model: @llm.canonical_name,
+          max_tokens: options[:max_output_tokens] || @llm.default_params[:max_output_tokens],
+          temperature: options[:temperature],
+          top_p: options[:top_p],
+          top_k: options[:top_k],
+          stream: options[:stream]
+        }.compact
+      end
+
+      def combined_system_messages(messages)
+        messages.filter { |m| m[:role].to_sym == :system }.map { |m| m[:content] }.join('\n\n')
+      end
+
+      def post_url(url, body:)
+        self.class.post(url, body: body, headers: default_headers)
+      end
+
+      def post_url_streaming(url, **kwargs, &block)
+        self.class.post(url, **kwargs.merge(headers: default_headers, stream_body: true), &block)
+      end
+
+      def default_headers
+        {
+          "anthropic-version" => "2023-06-01",
+          "x-api-key" => ENV["ANTHROPIC_API_KEY"],
+          "Content-Type" => "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/llm/clients/gemini/request.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class LLM
+  module Clients
+    class Gemini
+      class Request
+        def initialize(messages, options)
+          @messages = messages
+          @options = options
+        end
+
+        def model_for_url
+          "models/#{model}"
+        end
+
+        def params
+          {
+            systemInstruction: normalized_prompt,
+            contents: normalized_messages
+          }
+        end
+
+        private
+
+        attr_reader :messages, :options
+
+        def model
+          options[:model]
+        end
+
+        def normalized_messages
+          user_visible_messages
+            .map(&method(:message_to_gemini_message))
+        end
+
+        def message_to_gemini_message(message)
+          {
+            role: ROLES_MAP[message[:role]],
+            parts: [{text: message[:content]}]
+          }
+        end
+
+        def normalized_prompt
+          return nil if system_messages.empty?
+
+          system_messages
+            .map { |message| message[:content] }
+            .join("\n\n")
+        end
+
+        def system_messages
+          messages.filter { |message| message[:role] == :system }
+        end
+
+        def user_visible_messages
+          messages.filter { |message| message[:role] != :system }
+        end
+
+        ROLES_MAP = {
+          assistant: :model,
+          user: :user
+        }.freeze
+      end
+    end
+  end
+end

data/lib/llm/clients/gemini/response.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class LLM
+  module Clients
+    class Gemini
+      class Response
+        def initialize(raw_response)
+          @raw_response = raw_response
+        end
+
+        def to_normalized_response
+          LLM::Response.new(
+            content: content,
+            raw_response: parsed_response,
+            stop_reason: translated_stop_reason
+          )
+        end
+
+        def self.normalize_stop_reason(stop_reason)
+          case stop_reason
+          when "STOP"
+            LLM::StopReason::STOP
+          when "MAX_TOKENS"
+            LLM::StopReason::MAX_TOKENS
+          when "SAFETY"
+            LLM::StopReason::SAFETY
+          else
+            LLM::StopReason::OTHER
+          end
+        end
+
+        private
+
+        attr_reader :raw_response
+
+        def content
+          parsed_response.dig("candidates", 0, "content", "parts", 0, "text")
+        end
+
+        def stop_reason
+          parsed_response.dig("candidates", 0, "finishReason")
+        end
+
+        def translated_stop_reason
+          self.class.normalize_stop_reason(stop_reason)
+        end
+
+        def parsed_response
+          raw_response.parsed_response
+        end
+      end
+    end
+  end
+end

data/lib/llm/clients/gemini.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "event_stream_parser"
+
+class LLM
+  module Clients
+    class Gemini
+      include HTTParty
+      base_uri "https://generativelanguage.googleapis.com"
+
+      def initialize(llm:)
+        @llm = llm
+      end
+
+      def chat(messages, options = {})
+        req = Request.new(messages, options)
+
+        return chat_streaming(req, options[:on_message], options[:on_complete]) if options[:stream]
+
+        resp = post_url(
+          "/v1beta/models/#{llm.canonical_name}:generateContent",
+          body: req.params.to_json
+        )
+
+        Response.new(resp).to_normalized_response
+      end
+
+      private
+
+      attr_reader :llm
+
+      def chat_streaming(request, on_message, on_complete)
+        buffer = +""
+        chunks = []
+        output_data = {}
+
+        wrapped_on_complete = lambda { |stop_reason|
+          output_data[:stop_reason] = stop_reason
+          on_complete&.call(stop_reason)
+        }
+
+        proc = handle_event_stream(buffer, chunks, on_message_proc: on_message, on_complete_proc: wrapped_on_complete)
+
+        _resp = post_url_streaming(
+          "/v1beta/models/#{llm.canonical_name}:streamGenerateContent?alt=sse",
+          body: request.params.to_json,
+          &proc
+        )
+
+        LLM::Response.new(
+          content: buffer,
+          raw_response: chunks,
+          stop_reason: Response.normalize_stop_reason(output_data[:stop_reason])
+        )
+      end
+
+      def handle_event_stream(buffer, chunks, on_message_proc:, on_complete_proc:)
+        each_json_chunk do |_type, chunk|
+          chunks << chunk
+
+          new_content = chunk.dig("candidates", 0, "content", "parts", 0, "text")
+
+          unless new_content.nil?
+            on_message_proc&.call(new_content)
+            buffer << new_content
+          end
+
+          stop_reason = chunk.dig("candidates", 0, "finishReason")
+          on_complete_proc&.call(stop_reason) unless stop_reason.nil?
+        end
+      end
+
+      def each_json_chunk
+        parser = EventStreamParser::Parser.new
+
+        proc do |chunk|
+          # TODO: Add error handling.
+
+          parser.feed(chunk) do |type, data|
+            yield(type, JSON.parse(data))
+          end
+        end
+      end
+
+      def post_url(url, **kwargs)
+        self.class.post(url, **kwargs.merge(headers: default_headers))
+      end
+
+      def post_url_streaming(url, **kwargs, &block)
+        self.class.post(url, **kwargs.merge(headers: default_headers, stream_body: true), &block)
+      end
+
+      def default_headers
+        {
+          "x-goog-api-key" => ENV["GEMINI_API_KEY"],
+          "Content-Type" => "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/llm/clients/open_ai/response.rb

@@ -1,42 +1,48 @@
 # frozen_string_literal: true
 
-class LLM::Clients::OpenAI::Response
-  def initialize(raw_response)
-    @raw_response = raw_response
-  end
+class LLM
+  module Clients
+    class OpenAI
+      class Response
+        def initialize(raw_response)
+          @raw_response = raw_response
+        end
 
-  def to_normalized_response
-    LLM::Response.new(
-      content: content,
-      raw_response: parsed_response,
-      stop_reason: normalize_stop_reason
-    )
-  end
+        def to_normalized_response
+          LLM::Response.new(
+            content: content,
+            raw_response: parsed_response,
+            stop_reason: normalize_stop_reason
+          )
+        end
 
-  def self.normalize_stop_reason(stop_reason)
-    case stop_reason
-    when "stop"
-      LLM::StopReason::STOP
-    when "safety"
-      LLM::StopReason::SAFETY
-    when "max_tokens"
-      LLM::StopReason::MAX_TOKENS_REACHED
-    else
-      LLM::StopReason::OTHER
-    end
-  end
+        def self.normalize_stop_reason(stop_reason)
+          case stop_reason
+          when "stop"
+            LLM::StopReason::STOP
+          when "safety"
+            LLM::StopReason::SAFETY
+          when "max_tokens"
+            LLM::StopReason::MAX_TOKENS_REACHED
+          else
+            LLM::StopReason::OTHER
+          end
+        end
 
-  private
+        private
 
-  def content
-    parsed_response.dig("choices", 0, "message", "content")
-  end
+        def content
+          parsed_response.dig("choices", 0, "message", "content")
+        end
 
-  def normalize_stop_reason
-    self.class.normalize_stop_reason(parsed_response.dig("choices", 0, "finish_reason"))
-  end
+        def normalize_stop_reason
+          self.class.normalize_stop_reason(parsed_response.dig("choices", 0, "finish_reason"))
+        end
 
-  def parsed_response
-    @raw_response.parsed_response
+        def parsed_response
+          @raw_response.parsed_response
+        end
+      end
+    end
   end
 end

data/lib/llm/clients/open_ai.rb

@@ -3,107 +3,111 @@
 require "httparty"
 require "event_stream_parser"
 
-class LLM::Clients::OpenAI
-  include HTTParty
-  base_uri "https://api.openai.com/v1"
+class LLM
+  module Clients
+    class OpenAI
+      include HTTParty
+      base_uri "https://api.openai.com/v1"
+
+      def initialize(llm:)
+        @llm = llm
+      end
 
-  def initialize(llm:)
-    @llm = llm
-  end
+      def chat(messages, options = {})
+        parameters = {
+          model: @llm.canonical_name,
+          messages: messages,
+          temperature: options[:temperature],
+          response_format: options[:response_format],
+          max_tokens: options[:max_output_tokens],
+          top_p: options[:top_p],
+          stop: options[:stop_sequences],
+          presence_penalty: options[:presence_penalty],
+          frequency_penalty: options[:frequency_penalty],
+          tools: options[:tools],
+          tool_choice: options[:tool_choice]
+        }.compact
+
+        return chat_streaming(parameters, options[:on_message], options[:on_complete]) if options[:stream]
+
+        resp = post_url("/chat/completions", body: parameters.to_json)
+
+        Response.new(resp).to_normalized_response
+      end
 
-  def chat(messages, options = {})
-    parameters = {
-      model: @llm.canonical_name,
-      messages: messages,
-      temperature: options[:temperature],
-      response_format: options[:response_format],
-      max_tokens: options[:max_output_tokens],
-      top_p: options[:top_p],
-      stop: options[:stop_sequences],
-      presence_penalty: options[:presence_penalty],
-      frequency_penalty: options[:frequency_penalty],
-      tools: options[:tools],
-      tool_choice: options[:tool_choice]
-    }.compact
-
-    return chat_streaming(parameters, options[:on_message], options[:on_complete]) if options[:stream]
-
-    resp = post_url("/chat/completions", body: parameters.to_json)
-
-    Response.new(resp).to_normalized_response
-  end
+      private
 
-  private
+      def chat_streaming(parameters, on_message, on_complete)
+        buffer = +""
+        chunks = []
+        output_data = {}
 
-  def chat_streaming(parameters, on_message, on_complete)
-    buffer = +""
-    chunks = []
-    output_data = {}
+        wrapped_on_complete = lambda { |stop_reason|
+          output_data[:stop_reason] = stop_reason
+          on_complete&.call(stop_reason)
+        }
 
-    wrapped_on_complete = lambda { |stop_reason|
-      output_data[:stop_reason] = stop_reason
-      on_complete&.call(stop_reason)
-    }
+        parameters[:stream] = true
 
-    parameters[:stream] = true
+        proc = stream_proc(buffer, chunks, on_message, wrapped_on_complete)
 
-    proc = stream_proc(buffer, chunks, on_message, wrapped_on_complete)
+        parameters.delete(:on_message)
+        parameters.delete(:on_complete)
 
-    parameters.delete(:on_message)
-    parameters.delete(:on_complete)
+        _resp = post_url_streaming("/chat/completions", body: parameters.to_json, &proc)
 
-    _resp = post_url_streaming("/chat/completions", body: parameters.to_json, &proc)
+        LLM::Response.new(
+          content: buffer,
+          raw_response: chunks,
+          stop_reason: output_data[:stop_reason]
+        )
+      end
 
-    LLM::Response.new(
-      content: buffer,
-      raw_response: chunks,
-      stop_reason: output_data[:stop_reason]
-    )
-  end
+      def stream_proc(buffer, chunks, on_message, complete_proc)
+        each_json_chunk do |_type, event|
+          next if event == "[DONE]"
 
-  def stream_proc(buffer, chunks, on_message, complete_proc)
-    each_json_chunk do |_type, event|
-      next if event == "[DONE]"
+          chunks << event
+          new_content = event.dig("choices", 0, "delta", "content")
+          stop_reason = event.dig("choices", 0, "finish_reason")
 
-      chunks << event
-      new_content = event.dig("choices", 0, "delta", "content")
-      stop_reason = event.dig("choices", 0, "finish_reason")
+          buffer << new_content unless new_content.nil?
+          on_message&.call(new_content) unless new_content.nil?
+          complete_proc&.call(Response.normalize_stop_reason(stop_reason)) unless stop_reason.nil?
+        end
+      end
 
-      buffer << new_content unless new_content.nil?
-      on_message&.call(new_content) unless new_content.nil?
-      complete_proc&.call(Response.normalize_stop_reason(stop_reason)) unless stop_reason.nil?
-    end
-  end
+      def each_json_chunk
+        parser = EventStreamParser::Parser.new
 
-  def each_json_chunk
-    parser = EventStreamParser::Parser.new
+        proc do |chunk, _bytes, env|
+          if env && env.status != 200
+            raise_error = Faraday::Response::RaiseError.new
+            raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
+          end
 
-    proc do |chunk, _bytes, env|
-      if env && env.status != 200
-        raise_error = Faraday::Response::RaiseError.new
-        raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
-      end
+          parser.feed(chunk) do |type, data|
+            next if data == "[DONE]"
 
-      parser.feed(chunk) do |type, data|
-        next if data == "[DONE]"
-
-        yield(type, JSON.parse(data))
+            yield(type, JSON.parse(data))
+          end
+        end
       end
-    end
-  end
 
-  def post_url(url, **kwargs)
-    self.class.post(url, **kwargs.merge(headers: default_headers))
-  end
+      def post_url(url, **kwargs)
+        self.class.post(url, **kwargs.merge(headers: default_headers))
+      end
 
-  def post_url_streaming(url, **kwargs, &block)
-    self.class.post(url, **kwargs.merge(headers: default_headers, stream_body: true), &block)
-  end
+      def post_url_streaming(url, **kwargs, &block)
+        self.class.post(url, **kwargs.merge(headers: default_headers, stream_body: true), &block)
+      end
 
-  def default_headers
-    {
-      "Authorization" => "Bearer #{ENV["OPENAI_API_KEY"]}",
-      "Content-Type" => "application/json"
-    }
+      def default_headers
+        {
+          "Authorization" => "Bearer #{ENV["OPENAI_API_KEY"]}",
+          "Content-Type" => "application/json"
+        }
+      end
+    end
   end
 end

data/lib/llm/info.rb

@@ -1,94 +1,255 @@
 # frozen_string_literal: true
 
-module LLM::Info
-  KNOWN_MODELS = [
-    # Semantics of fields:
-    # - canonical_name (required): A string that uniquely identifies the model.
-    #   We use this string as the public identifier when users choose this model via the API.
-    # - display_name (required): A string that is displayed to the user when choosing this model via the UI.
+class LLM
+  module Info
+    KNOWN_MODELS = [
+      # Semantics of fields:
+      # - canonical_name (required): A string that uniquely identifies the model.
+      #   We use this string as the public identifier when users choose this model via the API.
+      # - display_name (required): A string that is displayed to the user when choosing this model via the UI.
+      # - client_class (required): The client class to be used for this model.
 
-    # GPT-3.5 Turbo Models
-    {
-      canonical_name: "gpt-3.5-turbo",
-      display_name: "GPT-3.5 Turbo",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-3.5-turbo-0125",
-      display_name: "GPT-3.5 Turbo 0125",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-3.5-turbo-16k",
-      display_name: "GPT-3.5 Turbo 16K",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-3.5-turbo-1106",
-      display_name: "GPT-3.5 Turbo 1106",
-      provider: :openai
-    },
+      # GPT-3.5 Turbo Models
+      {
+        canonical_name: "gpt-3.5-turbo",
+        display_name: "GPT-3.5 Turbo",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-3.5-turbo-0125",
+        display_name: "GPT-3.5 Turbo 0125",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-3.5-turbo-16k",
+        display_name: "GPT-3.5 Turbo 16K",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-3.5-turbo-1106",
+        display_name: "GPT-3.5 Turbo 1106",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
 
-    # GPT-4 Models
-    {
-      canonical_name: "gpt-4",
-      display_name: "GPT-4",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4-32k",
-      display_name: "GPT-4 32K",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4-1106-preview",
-      display_name: "GPT-4 Turbo 1106",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4-turbo-2024-04-09",
-      display_name: "GPT-4 Turbo 2024-04-09",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4-0125-preview",
-      display_name: "GPT-4 Turbo 0125",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4-turbo-preview",
-      display_name: "GPT-4 Turbo",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4-0613",
-      display_name: "GPT-4 0613",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4-32k-0613",
-      display_name: "GPT-4 32K 0613",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4o",
-      display_name: "GPT-4o",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4o-mini",
-      display_name: "GPT-4o Mini",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4o-2024-05-13",
-      display_name: "GPT-4o 2024-05-13",
-      provider: :openai
-    },
-    {
-      canonical_name: "gpt-4o-2024-08-06",
-      display_name: "GPT-4o 2024-08-06",
-      provider: :openai
-    }
-  ].freeze
+      # GPT-4 Models
+      {
+        canonical_name: "gpt-4",
+        display_name: "GPT-4",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4-1106-preview",
+        display_name: "GPT-4 Turbo 1106",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4-turbo-2024-04-09",
+        display_name: "GPT-4 Turbo 2024-04-09",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4-0125-preview",
+        display_name: "GPT-4 Turbo 0125",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4-turbo-preview",
+        display_name: "GPT-4 Turbo",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4-0613",
+        display_name: "GPT-4 0613",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4o",
+        display_name: "GPT-4o",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4o-mini",
+        display_name: "GPT-4o Mini",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4o-mini-2024-07-18",
+        display_name: "GPT-4o Mini 2024-07-18",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4o-2024-05-13",
+        display_name: "GPT-4o 2024-05-13",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4o-2024-08-06",
+        display_name: "GPT-4o 2024-08-06",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "gpt-4o-2024-11-20",
+        display_name: "GPT-4o 2024-11-20",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "chatgpt-4o-latest",
+        display_name: "ChatGPT 4o Latest",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "o1",
+        display_name: "o1",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "o1-2024-12-17",
+        display_name: "o1 2024-12-17",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "o1-preview",
+        display_name: "o1 Preview",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "o1-preview-2024-09-12",
+        display_name: "o1 Preview 2024-09-12",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "o1-mini",
+        display_name: "o1 Mini",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "o1-mini-2024-09-12",
+        display_name: "o1 Mini 2024-09-12",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "o3-mini",
+        display_name: "o3 Mini",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+      {
+        canonical_name: "o3-mini-2025-01-31",
+        display_name: "o3 Mini 2025-01-31",
+        provider: :openai,
+        client_class: LLM::Clients::OpenAI
+      },
+
+      # Anthropic Models
+      {
+        canonical_name: "claude-3-5-sonnet-20241022",
+        display_name: "Claude 3.5 Sonnet 2024-10-22",
+        provider: :anthropic,
+        client_class: LLM::Clients::Anthropic,
+        additional_default_required_parameters: {
+          max_output_tokens: 8192
+        }
+      },
+      {
+        canonical_name: "claude-3-5-haiku-20241022",
+        display_name: "Claude 3.5 Haiku 2024-10-22",
+        provider: :anthropic,
+        client_class: LLM::Clients::Anthropic,
+        additional_default_required_parameters: {
+          max_output_tokens: 8192
+        }
+      },
+      {
+        canonical_name: "claude-3-5-sonnet-20240620",
+        display_name: "Claude 3.5 Sonnet 2024-06-20",
+        provider: :anthropic,
+        client_class: LLM::Clients::Anthropic,
+        additional_default_required_parameters: {
+          max_output_tokens: 8192
+        }
+      },
+      {
+        canonical_name: "claude-3-opus-20240229",
+        display_name: "Claude 3.5 Opus 2024-02-29",
+        provider: :anthropic,
+        client_class: LLM::Clients::Anthropic,
+        additional_default_required_parameters: {
+          max_output_tokens: 4096
+        }
+      },
+      {
+        canonical_name: "claude-3-sonnet-20240229",
+        display_name: "Claude 3.5 Sonnet 2024-02-29",
+        provider: :anthropic,
+        client_class: LLM::Clients::Anthropic,
+        additional_default_required_parameters: {
+          max_output_tokens: 4096
+        }
+      },
+      {
+        canonical_name: "claude-3-haiku-20240307",
+        display_name: "Claude 3.5 Opus 2024-03-07",
+        provider: :anthropic,
+        client_class: LLM::Clients::Anthropic,
+        additional_default_required_parameters: {
+          max_output_tokens: 4096
+        }
+      },
+
+      # Google Models
+      {
+        canonical_name: "gemini-2.0-flash",
+        display_name: "Gemini 2.0 Flash",
+        provider: :google,
+        client_class: LLM::Clients::Gemini
+      },
+      {
+        canonical_name: "gemini-2.0-flash-lite-preview-02-05",
+        display_name: "Gemini 2.0 Flash Lite Preview 02-05",
+        provider: :google,
+        client_class: LLM::Clients::Gemini
+      },
+      {
+        canonical_name: "gemini-1.5-flash-8b",
+        display_name: "Gemini 1.5 Flash 8B",
+        provider: :google,
+        client_class: LLM::Clients::Gemini
+      },
+      {
+        canonical_name: "gemini-1.5-flash",
+        display_name: "Gemini 1.5 Flash",
+        provider: :google,
+        client_class: LLM::Clients::Gemini
+      },
+      {
+        canonical_name: "gemini-1.5-pro",
+        display_name: "Gemini 1.5 Pro",
+        provider: :google,
+        client_class: LLM::Clients::Gemini
+      }
+    ].freeze
+  end
 end

data/lib/llm/stop_reason.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
-module LLM::StopReason
-  STOP = :stop
-  SAFETY = :safety
-  MAX_TOKENS_REACHED = :max_tokens
+class LLM
+  module StopReason
+    STOP = :stop
+    SAFETY = :safety
+    MAX_TOKENS_REACHED = :max_tokens
+    STOP_SEQUENCE = :stop_sequence
 
-  OTHER = :other
+    OTHER = :other
+  end
 end

data/lib/llm.rb

@@ -13,7 +13,8 @@ class LLM
     @canonical_name = model[:canonical_name]
     @display_name = model[:display_name]
     @provider = model[:provider]
-    @client_class = LLM::Clients::OpenAI # TODO: Allow alternative client classes.
+    @client_class = model[:client_class]
+    @default_params = model[:additional_default_required_parameters] || {}
   end
 
   def client
@@ -22,7 +23,8 @@ class LLM
 
   attr_reader :canonical_name,
     :display_name,
-    :provider
+    :provider,
+    :default_params
 
   private
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: llm_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Gamble
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
+date: 2025-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -136,10 +135,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.23.0
-description: 
-email:
-- alex@context.ai
-- alec@context.ai
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -150,6 +145,11 @@ files:
 - README.md
 - Rakefile
 - lib/llm.rb
+- lib/llm/clients/anthropic.rb
+- lib/llm/clients/anthropic/response.rb
+- lib/llm/clients/gemini.rb
+- lib/llm/clients/gemini/request.rb
+- lib/llm/clients/gemini/response.rb
 - lib/llm/clients/open_ai.rb
 - lib/llm/clients/open_ai/response.rb
 - lib/llm/info.rb
@@ -157,13 +157,12 @@ files:
 - lib/llm/response.rb
 - lib/llm/stop_reason.rb
 - lib/llm/version.rb
-homepage: https://context.ai
+homepage: https://github.com/agamble/llm_ruby
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://context.ai
-  source_code_uri: https://github.com/contextco/llm_ruby
-post_install_message: 
+  homepage_uri: https://github.com/agamble/llm_ruby
+  source_code_uri: https://github.com/agamble/llm_ruby
 rdoc_options: []
 require_paths:
 - lib
@@ -178,8 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A client to interact with LLM APIs in a consistent way.
 test_files: []