llm.rb 0.2.0 → 0.3.0

data/spec/llm/conversation_spec.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-RSpec.describe LLM::Conversation do
+require "setup"
+
+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
@@ -54,3 +56,133 @@ RSpec.describe LLM::Conversation do
     include_examples "a multi-turn conversation"
   end
 end
+
+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 "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] }
+
+        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"
+          )
+        end
+      end
+    end
+
+    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 }
+
+        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
+
+      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 "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 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 "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",
+              vcr: {cassette_name: "openai/lazy_conversation/responses/successful_response"} do
+        subject(:message) { conversation.recent_message }
+
+        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
+
+      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
+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,11 +37,32 @@ 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
 
+  context "when given a thread of messages",
+          vcr: {cassette_name: "openai/completions/successful_response_thread"} 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"}
+      ]
+    end
+
+    it "has choices" do
+      expect(response).to have_attributes(
+        choices: [
+          have_attributes(
+            role: "assistant",
+            content: "My name is Pablo, and I'm 25 years old! How can I help you today, amigo?"
+          )
+        ]
+      )
+    end
+  end
+
   context "when given a 'bad request' response",
           vcr: {cassette_name: "openai/completions/bad_request"} do
     subject(:response) { openai.complete(URI("/foobar.exe"), :user) }

data/spec/openai/files_spec.rb

@@ -0,0 +1,150 @@
+# 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")) }
+    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(
+        id: instance_of(String),
+        filename: "haiku1.txt",
+        purpose: "assistants"
+      )
+    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")) }
+    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(
+        id: instance_of(String),
+        filename: "haiku2.txt",
+        purpose: "assistants"
+      )
+    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:) }
+    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(
+        id: instance_of(String),
+        filename: "haiku4.txt",
+        purpose: "assistants"
+      )
+    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 }
+    after { files.each { |file| provider.files.delete(file:) } }
+
+    it "is successful" do
+      expect(file).to be_instance_of(LLM::Response::FileList)
+    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"
+          )
+        ]
+      )
+    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 }
+    let(:bot) { LLM::Chat.new(provider).lazy }
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/freebsd.sysctl.pdf")) }
+    after { provider.files.delete(file:) }
+
+    before do
+      bot.respond(file)
+      bot.respond("Describe the contents of the file to me")
+      bot.respond("Your summary should be no more than ten words")
+    end
+
+    it "describes the document" do
+      is_expected.to eq("FreeBSD system control nodes implementation and usage overview.")
+    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 }
+    let(:bot) { LLM::Chat.new(provider).lazy }
+    let(:file) { provider.files.create(file: LLM::File("spec/fixtures/documents/freebsd.sysctl.pdf")) }
+    after { provider.files.delete(file:) }
+
+    before do
+      bot.respond([
+        "Describe the contents of the file to me",
+        "Your summary should be no more than ten words",
+        file
+      ])
+    end
+
+    it "describes the document" do
+      is_expected.to eq("FreeBSD kernel system control nodes overview and implementation.")
+    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

data/spec/openai/responses_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::OpenAI::Responses" do
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
+  let(:provider) { LLM.openai(token) }
+
+  context "when given a successful create operation",
+          vcr: {cassette_name: "openai/responses/successful_create"} do
+    subject { provider.responses.create("Hello", :developer) }
+
+    it "is successful" do
+      is_expected.to be_instance_of(LLM::Response::Output)
+    end
+
+    it "has outputs" do
+      is_expected.to have_attributes(
+        outputs: [instance_of(LLM::Message)]
+      )
+    end
+  end
+
+  context "when given a successful get operation",
+          vcr: {cassette_name: "openai/responses/successful_get"} do
+    let(:response) { provider.responses.create("Hello", :developer) }
+    subject { provider.responses.get(response) }
+
+    it "is successful" do
+      is_expected.to be_instance_of(LLM::Response::Output)
+    end
+
+    it "has outputs" do
+      is_expected.to have_attributes(
+        outputs: [instance_of(LLM::Message)]
+      )
+    end
+  end
+
+  context "when given a successful delete operation",
+          vcr: {cassette_name: "openai/responses/successful_delete"} do
+    let(:response) { provider.responses.create("Hello", :developer) }
+    subject { provider.responses.delete(response) }
+
+    it "is successful" do
+      is_expected.to have_attributes(
+        deleted: true
+      )
+    end
+  end
+end

data/spec/setup.rb

@@ -16,5 +16,13 @@ VCR.configure do |config|
   config.cassette_library_dir = "spec/fixtures/cassettes"
   config.hook_into :webmock
   config.configure_rspec_metadata!
+
+  ##
+  # scrub
   config.filter_sensitive_data("TOKEN") { ENV["LLM_SECRET"] }
+  config.before_record do
+    body = _1.response.body
+    body.gsub! %r|#{Regexp.escape("https://oaidalleapiprodscus.blob.core.windows.net/")}[^"]+|,
+               "https://openai.com/generated/image.png"
+  end
 end