llm.rb 0.2.1 → 0.3.0

data/lib/llm/response/filelist.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module LLM
+  ##
+  # The {LLM::Response::FileList LLM::Response::FileList} class represents a
+  # list of file objects that are returned by a provider. It is an Enumerable
+  # object, and can be used to iterate over the file objects in a way that is
+  # similar to an array. Each element is an instance of OpenStruct.
+  class Response::FileList < Response
+    include Enumerable
+
+    attr_accessor :files
+
+    def each(&)
+      @files.each(&)
+    end
+  end
+end

data/lib/llm/response/image.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module LLM
+  ##
+  # The {LLM::Response::Image LLM::Response::Image} class represents
+  # an image response. An image response might encapsulate one or more
+  # URLs, or a base64 encoded image -- depending on the provider.
+  class Response::Image < Response
+    ##
+    # Returns one or more image objects, or nil
+    # @return [Array<OpenStruct>, nil]
+    def images
+      parsed[:images].any? ? parsed[:images] : nil
+    end
+
+    ##
+    # Returns one or more image URLs, or nil
+    # @return [Array<String>, nil]
+    def urls
+      parsed[:urls].any? ? parsed[:urls] : nil
+    end
+
+    private
+
+    def parsed
+      @parsed ||= parse_image(body)
+    end
+  end
+end

data/lib/llm/response/output.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module LLM
+  class Response::Output < Response
+    ##
+    # @return [String]
+    #  Returns the id of the response
+    def id
+      parsed[:id]
+    end
+
+    ##
+    # @return [String]
+    #  Returns the model name
+    def model
+      parsed[:model]
+    end
+
+    ##
+    # @return [Array<LLM::Message>]
+    def outputs
+      parsed[:outputs]
+    end
+
+    ##
+    # @return [Integer]
+    #  Returns the input token count
+    def input_tokens
+      parsed[:input_tokens]
+    end
+
+    ##
+    # @return [Integer]
+    #  Returns the output token count
+    def output_tokens
+      parsed[:output_tokens]
+    end
+
+    ##
+    # @return [Integer]
+    #  Returns the total count of tokens
+    def total_tokens
+      parsed[:total_tokens]
+    end
+
+    private
+
+    ##
+    # @private
+    # @return [Hash]
+    #  Returns the parsed response from the provider
+    def parsed
+      @parsed ||= parse_output_response(body)
+    end
+  end
+end

data/lib/llm/response.rb

@@ -5,11 +5,14 @@ module LLM
     require "json"
     require_relative "response/completion"
     require_relative "response/embedding"
-
-    ##
-    # @return [Hash]
-    #  Returns the response body
-    attr_reader :body
+    require_relative "response/output"
+    require_relative "response/image"
+    require_relative "response/audio"
+    require_relative "response/audio_transcription"
+    require_relative "response/audio_translation"
+    require_relative "response/file"
+    require_relative "response/filelist"
+    require_relative "response/download_file"
 
     ##
     # @param [Net::HTTPResponse] res
@@ -18,7 +21,16 @@ module LLM
     #  Returns an instance of LLM::Response
     def initialize(res)
       @res = res
-      @body = JSON.parse(res.body)
+    end
+
+    ##
+    # Returns the response body
+    # @return [Hash, String]
+    def body
+      @body ||= case @res["content-type"]
+      when %r|\Aapplication/json\s*| then JSON.parse(@res.body)
+      else @res.body
+      end
     end
   end
 end

data/lib/llm/utils.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+##
+# @private
+module LLM::Utils
+  def camelcase(key)
+    key.to_s
+      .split("_")
+      .map.with_index { (_2 > 0) ? _1.capitalize : _1 }
+      .join
+  end
+
+  def snakecase(key)
+    key
+      .split(/([A-Z])/)
+      .map { (_1.size == 1) ? "_#{_1.downcase}" : _1 }
+      .join
+  end
+end

data/lib/llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LLM
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/llm.rb

@@ -2,14 +2,17 @@
 
 module LLM
   require_relative "llm/version"
+  require_relative "llm/utils"
   require_relative "llm/error"
   require_relative "llm/message"
   require_relative "llm/response"
+  require_relative "llm/mime"
+  require_relative "llm/multipart"
   require_relative "llm/file"
   require_relative "llm/model"
   require_relative "llm/provider"
-  require_relative "llm/conversation"
-  require_relative "llm/message_queue"
+  require_relative "llm/chat"
+  require_relative "llm/buffer"
   require_relative "llm/core_ext/ostruct"
 
   module_function

data/llm.gemspec

@@ -14,12 +14,11 @@ Gem::Specification.new do |spec|
                  "flexible, and easy to use."
   spec.description = spec.summary
   spec.homepage = "https://github.com/llmrb/llm"
-  spec.license = "MIT"
+  spec.license = "0BSDL"
   spec.required_ruby_version = ">= 3.0.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/llmrb/llm"
-  spec.metadata["changelog_uri"] = "https://github.com/llmrb/llm/blob/main/CHANGELOG.md"
 
   spec.files = Dir[
     "README.md", "LICENSE.txt",
@@ -29,10 +28,6 @@ Gem::Specification.new do |spec|
   ]
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "net-http", "~> 0.6.0"
-  spec.add_runtime_dependency "json"
-  spec.add_runtime_dependency "yaml"
-
   spec.add_development_dependency "webmock", "~> 3.24.0"
   spec.add_development_dependency "yard", "~> 0.9.37"
   spec.add_development_dependency "kramdown", "~> 2.4"

data/spec/anthropic/completion_spec.rb

@@ -37,7 +37,7 @@ RSpec.describe "LLM::Anthropic: completions" do
       end
 
       it "includes the response" do
-        expect(choice.extra[:completion]).to eq(response)
+        expect(choice.extra[:response]).to eq(response)
       end
     end
   end

data/spec/gemini/completion_spec.rb

@@ -41,7 +41,7 @@ RSpec.describe "LLM::Gemini: completions" do
       end
 
       it "includes the response" do
-        expect(choice.extra[:completion]).to eq(response)
+        expect(choice.extra[:response]).to eq(response)
       end
     end
   end

data/spec/gemini/conversation_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::Chat: gemini" do
+  let(:described_class) { LLM::Chat }
+  let(:provider) { LLM.gemini(token) }
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
+  let(:conversation) { described_class.new(provider, **params).lazy }
+
+  context "when asked to describe an image",
+          vcr: {cassette_name: "gemini/conversations/multimodal_response"} do
+    subject { conversation.last_message }
+
+    let(:params) { {} }
+    let(:image) { LLM::File("spec/fixtures/images/bluebook.png") }
+
+    before do
+      conversation.chat(image, :user)
+      conversation.chat("Describe the image with a short sentance", :user)
+    end
+
+    it "describes the image" do
+      is_expected.to have_attributes(
+        role: "model",
+        content: "That's a simple illustration of a book " \
+                 "resting on a blue, X-shaped book stand.\n"
+      )
+    end
+  end
+end

data/spec/gemini/files_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::Gemini::Files" do
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
+  let(:provider) { LLM.gemini(token) }
+
+  context "when given a successful create operation (bismillah.mp3)",
+          vcr: {cassette_name: "gemini/files/successful_create_bismillah"} do
+    subject(:file) { provider.files.create(file: LLM::File("spec/fixtures/audio/bismillah.mp3")) }
+    after { provider.files.delete(file:) }
+
+    it "is successful" do
+      expect(file).to be_instance_of(LLM::Response::File)
+    end
+
+    it "returns a file object" do
+      expect(file).to have_attributes(
+        name: instance_of(String),
+        display_name: "bismillah.mp3"
+      )
+    end
+  end
+
+  context "when given a successful delete operation (bismillah.mp3)",
+          vcr: {cassette_name: "gemini/files/successful_delete_bismillah"} do
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/audio/bismillah.mp3")) }
+    subject { provider.files.delete(file:) }
+
+    it "is successful" do
+      is_expected.to be_instance_of(Net::HTTPOK)
+    end
+  end
+
+  context "when given a successful get operation (bismillah.mp3)",
+          vcr: {cassette_name: "gemini/files/successful_get_bismillah"} do
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/audio/bismillah.mp3")) }
+    subject { provider.files.get(file:) }
+    after { provider.files.delete(file:) }
+
+    it "is successful" do
+      is_expected.to be_instance_of(LLM::Response::File)
+    end
+
+    it "returns a file object" do
+      is_expected.to have_attributes(
+        name: instance_of(String),
+        display_name: "bismillah.mp3"
+      )
+    end
+  end
+
+  context "when given a successful translation operation (bismillah.mp3)",
+          vcr: {cassette_name: "gemini/files/successful_translation_bismillah"} do
+    subject { bot.last_message.content }
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/audio/bismillah.mp3")) }
+    let(:bot) { LLM::Chat.new(provider).lazy }
+    after { provider.files.delete(file:) }
+
+    before do
+      bot.chat file
+      bot.chat "Translate the contents of the audio file into English"
+      bot.chat "The audio is referenced in the first message I sent to you"
+      bot.chat "Provide no other content except the translation"
+    end
+
+    it "translates the audio clip" do
+      is_expected.to eq("In the name of God, the Most Gracious, the Most Merciful.\n")
+    end
+  end
+
+  context "when given a successful translation operation (alhamdullilah.mp3)",
+          vcr: {cassette_name: "gemini/files/successful_translation_alhamdullilah"} do
+    subject { bot.last_message.content }
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/audio/alhamdullilah.mp3")) }
+    let(:bot) { LLM::Chat.new(provider).lazy }
+    after { provider.files.delete(file:) }
+
+    before do
+      bot.chat [
+        "Translate the contents of the audio file into English",
+        "Provide no other content except the translation",
+        file
+      ]
+    end
+
+    it "translates the audio clip" do
+      is_expected.to eq("All praise is due to Allah, Lord of the Worlds.\n")
+    end
+  end
+
+  context "when given a successful all operation",
+          vcr: {cassette_name: "gemini/files/successful_all"} do
+    let!(:files) do
+      [
+        provider.files.create(file: LLM::File("spec/fixtures/audio/bismillah.mp3")),
+        provider.files.create(file: LLM::File("spec/fixtures/audio/alhamdullilah.mp3"))
+      ]
+    end
+
+    subject(:response) { provider.files.all }
+    after { files.each { |file| provider.files.delete(file:) } }
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::FileList)
+    end
+
+    it "returns an array of file objects" do
+      expect(response).to match_array(
+        [
+          have_attributes(
+            name: instance_of(String),
+            display_name: "bismillah.mp3"
+          ),
+          have_attributes(
+            name: instance_of(String),
+            display_name: "alhamdullilah.mp3"
+          )
+        ]
+      )
+    end
+  end
+end

data/spec/gemini/images_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::Gemini::Images" do
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
+  let(:provider) { LLM.gemini(token) }
+
+  context "when given a successful create operation",
+        vcr: {cassette_name: "gemini/images/successful_create"} do
+    subject(:response) { provider.images.create(prompt: "A dog on a rocket to the moon") }
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::Image)
+    end
+
+    it "returns an encoded string" do
+      expect(response.images[0].encoded).to be_instance_of(String)
+    end
+
+    it "returns a binary string" do
+      expect(response.images[0].binary).to be_instance_of(String)
+    end
+  end
+
+  context "when given a successful edit operation",
+        vcr: {cassette_name: "gemini/images/successful_edit"} do
+    subject(:response) do
+      provider.images.edit(
+        image: LLM::File("spec/fixtures/images/bluebook.png"),
+        prompt: "Book is floating in the clouds"
+      )
+    end
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::Image)
+    end
+
+    it "returns data" do
+      expect(response.images[0].encoded).to be_instance_of(String)
+    end
+
+    it "returns a url" do
+      expect(response.images[0].binary).to be_instance_of(String)
+    end
+  end
+end

data/spec/llm/conversation_spec.rb

@@ -2,7 +2,7 @@
 
 require "setup"
 
-RSpec.describe "LLM::Conversation: non-lazy" do
+RSpec.describe "LLM::Chat: non-lazy" do
   shared_examples "a multi-turn conversation" do
     context "when given a thread of messages" do
       let(:inputs) do
@@ -57,91 +57,131 @@ RSpec.describe "LLM::Conversation: non-lazy" do
   end
 end
 
-RSpec.describe "LLM::Conversation: lazy" do
-  let(:described_class) { LLM::Conversation }
+RSpec.describe "LLM::Chat: lazy" do
+  let(:described_class) { LLM::Chat }
   let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
   let(:prompt) { "Keep your answers short and concise, and provide three answers to the three questions" }
 
-  context "with gemini",
-          vcr: {cassette_name: "gemini/lazy_conversation/successful_response"} do
-    let(:provider) { LLM.gemini(token) }
-    let(:conversation) { described_class.new(provider).lazy }
+  context "when given completions" do
+    context "with gemini",
+            vcr: {cassette_name: "gemini/lazy_conversation/successful_response"} do
+      let(:provider) { LLM.gemini(token) }
+      let(:conversation) { described_class.new(provider).lazy }
 
-    context "when given a thread of messages" do
-      subject(:message) { conversation.messages.to_a[-1] }
+      context "when given a thread of messages" do
+        subject(:message) { conversation.messages.to_a[-1] }
 
-      before do
-        conversation.chat prompt
-        conversation.chat "What is 3+2 ?"
-        conversation.chat "What is 5+5 ?"
-        conversation.chat "What is 5+7 ?"
-      end
+        before do
+          conversation.chat prompt
+          conversation.chat "What is 3+2 ?"
+          conversation.chat "What is 5+5 ?"
+          conversation.chat "What is 5+7 ?"
+        end
 
-      it "maintains a conversation" do
-        is_expected.to have_attributes(
-          role: "model",
-          content: "5\n10\n12\n"
-        )
+        it "maintains a conversation" do
+          is_expected.to have_attributes(
+            role: "model",
+            content: "5\n10\n12\n"
+          )
+        end
       end
     end
-  end
 
-  context "with openai"  do
-    let(:provider) { LLM.openai(token) }
-    let(:conversation) { described_class.new(provider).lazy }
+    context "with openai"  do
+      let(:provider) { LLM.openai(token) }
+      let(:conversation) { described_class.new(provider).lazy }
 
-    context "when given a thread of messages",
-            vcr: {cassette_name: "openai/lazy_conversation/successful_response"} do
-      subject(:message) { conversation.recent_message }
+      context "when given a thread of messages",
+              vcr: {cassette_name: "openai/lazy_conversation/completions/successful_response"} do
+        subject(:message) { conversation.recent_message }
 
-      before do
-        conversation.chat prompt, :system
-        conversation.chat "What is 3+2 ?"
-        conversation.chat "What is 5+5 ?"
-        conversation.chat "What is 5+7 ?"
+        before do
+          conversation.chat prompt, :system
+          conversation.chat "What is 3+2 ?"
+          conversation.chat "What is 5+5 ?"
+          conversation.chat "What is 5+7 ?"
+        end
+
+        it "maintains a conversation" do
+          is_expected.to have_attributes(
+            role: "assistant",
+            content: "1. 5  \n2. 10  \n3. 12  "
+          )
+        end
       end
 
-      it "maintains a conversation" do
-        is_expected.to have_attributes(
-          role: "assistant",
-          content: "1. 5  \n2. 10  \n3. 12  "
-        )
+      context "when given a specific model",
+              vcr: {cassette_name: "openai/lazy_conversation/completions/successful_response_o3_mini"} do
+        let(:conversation) { described_class.new(provider, model: provider.models["o3-mini"]).lazy }
+
+        it "maintains the model throughout a conversation" do
+          conversation.chat(prompt, :system)
+          expect(conversation.recent_message.extra[:response].model).to eq("o3-mini-2025-01-31")
+          conversation.chat("What is 5+5?")
+          expect(conversation.recent_message.extra[:response].model).to eq("o3-mini-2025-01-31")
+        end
       end
     end
 
-    context "when given a specific model",
-            vcr: {cassette_name: "openai/lazy_conversation/successful_response_o3_mini"} do
-      let(:conversation) { described_class.new(provider, model: provider.models["o3-mini"]).lazy }
+    context "with ollama",
+            vcr: {cassette_name: "ollama/lazy_conversation/successful_response"} do
+      let(:provider) { LLM.ollama(nil, host: "eel.home.network") }
+      let(:conversation) { described_class.new(provider).lazy }
 
-      it "maintains the model throughout a conversation" do
-        conversation.chat(prompt, :system)
-        expect(conversation.recent_message.extra[:completion].model).to eq("o3-mini-2025-01-31")
-        conversation.chat("What is 5+5?")
-        expect(conversation.recent_message.extra[:completion].model).to eq("o3-mini-2025-01-31")
+      context "when given a thread of messages" do
+        subject(:message) { conversation.recent_message }
+
+        before do
+          conversation.chat prompt, :system
+          conversation.chat "What is 3+2 ?"
+          conversation.chat "What is 5+5 ?"
+          conversation.chat "What is 5+7 ?"
+        end
+
+        it "maintains a conversation" do
+          is_expected.to have_attributes(
+            role: "assistant",
+            content: "Here are the calculations:\n\n1. 3 + 2 = 5\n2. 5 + 5 = 10\n3. 5 + 7 = 12"
+          )
+        end
       end
     end
   end
 
-  context "with ollama",
-          vcr: {cassette_name: "ollama/lazy_conversation/successful_response"} do
-    let(:provider) { LLM.ollama(nil, host: "eel.home.network") }
-    let(:conversation) { described_class.new(provider).lazy }
+  context "when given responses" do
+    context "with openai"  do
+      let(:provider) { LLM.openai(token) }
+      let(:conversation) { described_class.new(provider).lazy }
 
-    context "when given a thread of messages" do
-      subject(:message) { conversation.recent_message }
+      context "when given a thread of messages",
+              vcr: {cassette_name: "openai/lazy_conversation/responses/successful_response"} do
+        subject(:message) { conversation.recent_message }
 
-      before do
-        conversation.chat prompt, :system
-        conversation.chat "What is 3+2 ?"
-        conversation.chat "What is 5+5 ?"
-        conversation.chat "What is 5+7 ?"
+        before do
+          conversation.respond prompt, :developer
+          conversation.respond "What is 3+2 ?"
+          conversation.respond "What is 5+5 ?"
+          conversation.respond "What is 5+7 ?"
+        end
+
+        it "maintains a conversation" do
+          is_expected.to have_attributes(
+            role: "assistant",
+            content: "1. 3 + 2 = 5  \n2. 5 + 5 = 10  \n3. 5 + 7 = 12"
+          )
+        end
       end
 
-      it "maintains a conversation" do
-        is_expected.to have_attributes(
-          role: "assistant",
-          content: "Here are the calculations:\n\n1. 3 + 2 = 5\n2. 5 + 5 = 10\n3. 5 + 7 = 12"
-        )
+      context "when given a specific model",
+              vcr: {cassette_name: "openai/lazy_conversation/responses/successful_response_o3_mini"} do
+        let(:conversation) { described_class.new(provider, model: provider.models["o3-mini"]).lazy }
+
+        it "maintains the model throughout a conversation" do
+          conversation.respond(prompt, :developer)
+          expect(conversation.last_message.extra[:response].model).to eq("o3-mini-2025-01-31")
+          conversation.respond("What is 5+5?")
+          expect(conversation.last_message.extra[:response].model).to eq("o3-mini-2025-01-31")
+        end
       end
     end
   end

data/spec/ollama/completion_spec.rb

@@ -36,7 +36,7 @@ RSpec.describe "LLM::Ollama: completions" do
       end
 
       it "includes the response" do
-        expect(choice.extra[:completion]).to eq(response)
+        expect(choice.extra[:response]).to eq(response)
       end
     end
   end