llm.rb 0.2.1 → 0.3.1

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,136 @@ 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" }
+  let(:prompt) do
+    "Keep your answers short and concise, and provide three answers to the three questions" \
+    "There should be one answer per line" \
+    "An answer should be a number, for example: 5" \
+    "Nothing else"
+  end
 
-  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/completions/successful_response"} do
+        subject(:message) { conversation.recent_message }
 
-    context "when given a thread of messages",
-            vcr: {cassette_name: "openai/lazy_conversation/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 ?"
+        end
 
-      before do
-        conversation.chat prompt, :system
-        conversation.chat "What is 3+2 ?"
-        conversation.chat "What is 5+5 ?"
-        conversation.chat "What is 5+7 ?"
+        it "maintains a conversation" do
+          is_expected.to have_attributes(
+            role: "assistant",
+            content: %r|5\s*\n10\s*\n12\s*|
+          )
+        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 }
+
+      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 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")
+        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: %r|5\s*\n10\s*\n12\s*|
+          )
+        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

data/spec/ollama/conversation_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::Chat: ollama" do
+  let(:described_class) { LLM::Chat }
+  let(:provider) { LLM.ollama(nil, host: "eel.home.network") }
+  let(:conversation) { described_class.new(provider, **params).lazy }
+
+  context "when asked to describe an image",
+          vcr: {cassette_name: "ollama/conversations/multimodal_response"} do
+    subject { conversation.last_message }
+
+    let(:params) { {model: "llava"} }
+    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: "assistant",
+        content: " The image is a graphic illustration of a book" \
+                 " with its pages spread out, symbolizing openness" \
+                 " or knowledge. "
+      )
+    end
+  end
+end

data/spec/openai/audio_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::OpenAI::Audio" do
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
+  let(:provider) { LLM.openai(token) }
+
+  context "when given a successful create operation",
+        vcr: {cassette_name: "openai/audio/successful_create"} do
+    subject(:response) { provider.audio.create_speech(input: "A dog on a rocket to the moon") }
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::Audio)
+    end
+
+    it "returns an audio" do
+      expect(response.audio).to be_instance_of(StringIO)
+    end
+  end
+
+  context "when given a successful transcription operation",
+        vcr: {cassette_name: "openai/audio/successful_transcription"} do
+    subject(:response) do
+      provider.audio.create_transcription(
+        file: LLM::File("spec/fixtures/audio/rocket.mp3")
+      )
+    end
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::AudioTranscription)
+    end
+
+    it "returns a transcription" do
+      expect(response.text).to eq("A dog on a rocket to the moon.")
+    end
+  end
+
+  context "when given a successful translation operation",
+        vcr: {cassette_name: "openai/audio/successful_translation"} do
+    subject(:response) do
+      provider.audio.create_translation(
+        file: LLM::File("spec/fixtures/audio/bismillah.mp3")
+      )
+    end
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::AudioTranslation)
+    end
+
+    it "returns a translation (Arabic => English)" do
+      expect(response.text).to eq("In the name of Allah, the Beneficent, the Merciful.")
+    end
+  end
+end

data/spec/openai/completion_spec.rb

@@ -37,7 +37,7 @@ RSpec.describe "LLM::OpenAI: 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
@@ -47,7 +47,8 @@ RSpec.describe "LLM::OpenAI: completions" do
     subject(:response) do
       openai.complete "What is your name? What age are you?", :user, messages: [
         {role: "system", content: "Answer all of my questions"},
-        {role: "system", content: "Your name is Pablo, you are 25 years old and you are my amigo"}
+        {role: "system", content: "Answer in the format: My name is <name> and I am <age> years old"},
+        {role: "system", content: "Your name is Pablo and you are 25 years old"},
       ]
     end
 
@@ -56,7 +57,7 @@ RSpec.describe "LLM::OpenAI: completions" do
         choices: [
           have_attributes(
             role: "assistant",
-            content: "My name is Pablo, and I'm 25 years old! How can I help you today, amigo?"
+            content: %r|\AMy name is Pablo and I am 25 years old|
           )
         ]
       )
@@ -68,7 +69,7 @@ RSpec.describe "LLM::OpenAI: completions" do
     subject(:response) { openai.complete(URI("/foobar.exe"), :user) }
 
     it "raises an error" do
-      expect { response }.to raise_error(LLM::Error::BadResponse)
+      expect { response }.to raise_error(LLM::Error::ResponseError)
     end
 
     it "includes the response" do

data/spec/openai/files_spec.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::OpenAI::Files" do
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
+  let(:provider) { LLM.openai(token) }
+
+  context "when given a successful create operation (haiku1.txt)",
+          vcr: {cassette_name: "openai/files/successful_create_haiku1"} do
+    subject(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/haiku1.txt")) }
+
+    it "is successful" do
+      expect(file).to be_instance_of(LLM::Response::File)
+    ensure
+      provider.files.delete(file:)
+    end
+
+    it "returns a file object" do
+      expect(file).to have_attributes(
+        id: instance_of(String),
+        filename: "haiku1.txt",
+        purpose: "assistants"
+      )
+    ensure
+      provider.files.delete(file:)
+    end
+  end
+
+  context "when given a successful create operation (haiku2.txt)",
+          vcr: {cassette_name: "openai/files/successful_create_haiku2"} do
+    subject(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/haiku2.txt")) }
+
+    it "is successful" do
+      expect(file).to be_instance_of(LLM::Response::File)
+    ensure
+      provider.files.delete(file:)
+    end
+
+    it "returns a file object" do
+      expect(file).to have_attributes(
+        id: instance_of(String),
+        filename: "haiku2.txt",
+        purpose: "assistants"
+      )
+    ensure
+      provider.files.delete(file:)
+    end
+  end
+
+  context "when given a successful delete operation (haiku3.txt)",
+          vcr: {cassette_name: "openai/files/successful_delete_haiku3"} do
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/haiku3.txt")) }
+    subject { provider.files.delete(file:) }
+
+    it "is successful" do
+      is_expected.to be_instance_of(OpenStruct)
+    end
+
+    it "returns deleted status" do
+      is_expected.to have_attributes(
+        deleted: true
+      )
+    end
+  end
+
+  context "when given a successful get operation (haiku4.txt)",
+          vcr: {cassette_name: "openai/files/successful_get_haiku4"} do
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/haiku4.txt")) }
+    subject { provider.files.get(file:) }
+
+    it "is successful" do
+      is_expected.to be_instance_of(LLM::Response::File)
+    ensure
+      provider.files.delete(file:)
+    end
+
+    it "returns a file object" do
+      is_expected.to have_attributes(
+        id: instance_of(String),
+        filename: "haiku4.txt",
+        purpose: "assistants"
+      )
+    ensure
+      provider.files.delete(file:)
+    end
+  end
+
+  context "when given a successful all operation",
+          vcr: {cassette_name: "openai/files/successful_all"} do
+    let!(:files) do
+      [
+        provider.files.create(file: LLM::File("spec/fixtures/documents/haiku1.txt")),
+        provider.files.create(file: LLM::File("spec/fixtures/documents/haiku2.txt"))
+      ]
+    end
+    subject(:file) { provider.files.all }
+
+    it "is successful" do
+      expect(file).to be_instance_of(LLM::Response::FileList)
+    ensure
+      files.each { |file| provider.files.delete(file:) }
+    end
+
+    it "returns an array of file objects" do
+      expect(file).to match_array(
+        [
+          have_attributes(
+            id: instance_of(String),
+            filename: "haiku1.txt",
+            purpose: "assistants"
+          ),
+          have_attributes(
+            id: instance_of(String),
+            filename: "haiku2.txt",
+            purpose: "assistants"
+          )
+        ]
+      )
+    ensure
+      files.each { |file| provider.files.delete(file:) }
+    end
+  end
+
+  context "when asked to describe the contents of a file",
+          vcr: {cassette_name: "openai/files/describe_freebsd.sysctl.pdf"} do
+    subject { bot.last_message.content.downcase[0..2] }
+    let(:bot) { LLM::Chat.new(provider).lazy }
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/freebsd.sysctl.pdf")) }
+
+    before do
+      bot.respond(file)
+      bot.respond("Is this PDF document about FreeBSD?")
+      bot.respond("Answer with yes or no. Nothing else.")
+    end
+
+    it "describes the document" do
+      is_expected.to eq("yes")
+    ensure
+      provider.files.delete(file:)
+    end
+  end
+
+  context "when asked to describe the contents of a file",
+          vcr: {cassette_name: "openai/files/describe_freebsd.sysctl_2.pdf"} do
+    subject { bot.last_message.content.downcase[0..2] }
+    let(:bot) { LLM::Chat.new(provider).lazy }
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/freebsd.sysctl.pdf")) }
+
+    before do
+      bot.respond([
+        "Is this PDF document about FreeBSD?",
+        "Answer with yes or no. Nothing else.",
+        file
+      ])
+    end
+
+    it "describes the document" do
+      is_expected.to eq("yes")
+    ensure
+      provider.files.delete(file:)
+    end
+  end
+
+  context "when asked to describe the contents of a file",
+          vcr: {cassette_name: "openai/files/describe_freebsd.sysctl_3.pdf"} do
+    subject { bot.last_message.content.downcase[0..2] }
+    let(:bot) { LLM::Chat.new(provider).lazy }
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/freebsd.sysctl.pdf")) }
+
+    before do
+      bot.chat(file)
+      bot.chat("Is this PDF document about FreeBSD?")
+      bot.chat("Answer with yes or no. Nothing else.")
+    end
+
+    it "describes the document" do
+      is_expected.to eq("yes")
+    ensure
+      provider.files.delete(file:)
+    end
+  end
+
+  context "when asked to describe the contents of a file",
+          vcr: {cassette_name: "openai/files/describe_freebsd.sysctl_4.pdf"} do
+    subject { bot.last_message.content.downcase[0..2] }
+    let(:bot) { LLM::Chat.new(provider).lazy }
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/freebsd.sysctl.pdf")) }
+
+    before do
+      bot.chat([
+        "Is this PDF document about FreeBSD?",
+        "Answer with yes or no. Nothing else.",
+        file
+      ])
+    end
+
+    it "describes the document" do
+      is_expected.to eq("yes")
+    ensure
+      provider.files.delete(file:)
+    end
+  end
+end

data/spec/openai/images_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::OpenAI::Images" do
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
+  let(:provider) { LLM.openai(token) }
+
+  context "when given a successful create operation (urls)",
+          vcr: {cassette_name: "openai/images/successful_create_urls"} 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 array of urls" do
+      expect(response.urls).to be_instance_of(Array)
+    end
+
+    it "returns a url" do
+      expect(response.urls[0]).to be_instance_of(String)
+    end
+  end
+
+  context "when given a successful create operation (base64)",
+          vcr: {cassette_name: "openai/images/successful_create_base64"} do
+    subject(:response) do
+      provider.images.create(
+        prompt: "A dog on a rocket to the moon",
+        response_format: "b64_json"
+      )
+    end
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::Image)
+    end
+
+    it "returns an array of images" do
+      expect(response.images).to be_instance_of(Array)
+    end
+
+    it "returns an encoded string" do
+      expect(response.images[0].encoded).to be_instance_of(String)
+    end
+
+    it "returns an binary string" do
+      expect(response.images[0].binary).to be_instance_of(String)
+    end
+  end
+
+  context "when given a successful variation operation",
+        vcr: {cassette_name: "openai/images/successful_variation"} do
+    subject(:response) do
+      provider.images.create_variation(
+        image: LLM::File("spec/fixtures/images/bluebook.png"),
+        n: 5
+      )
+    end
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::Image)
+    end
+
+    it "returns data" do
+      expect(response.urls.size).to eq(5)
+    end
+
+    it "returns multiple variations" do
+      response.urls.each { expect(_1).to be_instance_of(String) }
+    end
+  end
+
+  context "when given a successful edit",
+        vcr: {cassette_name: "openai/images/successful_edit"} do
+    subject(:response) do
+      provider.images.edit(
+        image: LLM::File("spec/fixtures/images/bluebook.png"),
+        prompt: "Add white background"
+      )
+    end
+
+    it "is successful" do
+      expect(response).to be_instance_of(LLM::Response::Image)
+    end
+
+    it "returns data" do
+      expect(response.urls).to be_instance_of(Array)
+    end
+
+    it "returns a url" do
+      expect(response.urls[0]).to be_instance_of(String)
+    end
+  end
+end