llm.rb 0.4.0 → 0.4.2

data/spec/gemini/files_spec.rb

@@ -1,124 +0,0 @@
-# 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 Allah, 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

@@ -1,39 +0,0 @@
-# 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 IO-like object" do
-      expect(response.images[0]).to be_instance_of(StringIO)
-    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 an IO-like object" do
-      expect(response.images[0]).to be_instance_of(StringIO)
-    end
-  end
-end

data/spec/gemini/models_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "setup"
-
-RSpec.describe "LLM::Gemini::Models" do
-  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
-  let(:provider) { LLM.gemini(token) }
-
-  context "when given a successful list operation",
-          vcr: {cassette_name: "gemini/models/successful_list"} do
-    subject { provider.models.all }
-
-    it "is successful" do
-      is_expected.to be_instance_of(LLM::Response::ModelList)
-    end
-
-    it "returns a list of models" do
-      expect(subject.models).to all(be_a(LLM::Model))
-    end
-  end
-end

data/spec/llm/conversation_spec.rb

@@ -1,261 +0,0 @@
-# frozen_string_literal: true
-
-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
-        [
-          LLM::Message.new(:system, "Provide concise, short answers about The Netherlands"),
-          LLM::Message.new(:user, "What is the capital of The Netherlands?"),
-          LLM::Message.new(:user, "How many people live in the capital?")
-        ]
-      end
-
-      let(:outputs) do
-        [
-          LLM::Message.new(:assistant, "Ok, got it"),
-          LLM::Message.new(:assistant, "The capital of The Netherlands is Amsterdam"),
-          LLM::Message.new(:assistant, "The population of Amsterdam is about 900,000")
-        ]
-      end
-
-      let(:messages) { [] }
-
-      it "maintains a conversation" do
-        bot = nil
-        inputs.zip(outputs).each_with_index do |(input, output), index|
-          expect(provider).to receive(:complete)
-                                .with(input.content, instance_of(Symbol), messages:, model: provider.default_model, schema: nil)
-                                .and_return(OpenStruct.new(choices: [output]))
-          bot = index.zero? ? provider.chat!(input.content, :system) : bot.chat(input.content)
-          messages.concat([input, output])
-        end
-      end
-    end
-  end
-
-  context "with openai" do
-    subject(:provider) { LLM.openai("") }
-    include_examples "a multi-turn conversation"
-  end
-
-  context "with gemini" do
-    subject(:provider) { LLM.gemini("") }
-    include_examples "a multi-turn conversation"
-  end
-
-  context "with anthropic" do
-    subject(:provider) { LLM.anthropic("") }
-    include_examples "a multi-turn conversation"
-  end
-
-  context "with ollama" do
-    subject(:provider) { LLM.ollama("") }
-    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) 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 "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: %r|5\s*\n10\s*\n12\s*|
-          )
-        end
-      end
-
-      context "when given a specific model",
-              vcr: {cassette_name: "openai/lazy_conversation/completions/successful_response_o3_mini"} do
-        let(:model) { provider.models.all.find { _1.id == "o3-mini" } }
-        let(:conversation) { described_class.new(provider, model:).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: %r|5\s*\n10\s*\n12\s*|
-          )
-        end
-      end
-
-      context "when given a specific model",
-              vcr: {cassette_name: "openai/lazy_conversation/responses/successful_response_o3_mini"} do
-        let(:model) { provider.models.all.find { _1.id == "o3-mini" } }
-        let(:conversation) { described_class.new(provider, model:).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
-
-  context "when given a schema as JSON" do
-    context "with openai" do
-      let(:provider) { LLM.openai(token) }
-      let(:conversation) { described_class.new(provider, schema:).lazy }
-
-      context "when given a schema",
-              vcr: {cassette_name: "openai/lazy_conversation/completions/successful_response_schema_netbsd"} do
-        subject(:message) { conversation.recent_message.content! }
-        let(:schema) { provider.schema.object({os: provider.schema.string.enum("OpenBSD", "FreeBSD", "NetBSD")}) }
-
-        before do
-          conversation.chat "You secretly love NetBSD", :system
-          conversation.chat "What operating system is the best?", :user
-        end
-
-        it "formats the response" do
-          is_expected.to eq("os" => "NetBSD")
-        end
-      end
-    end
-
-    context "with gemini" do
-      let(:provider) { LLM.gemini(token) }
-      let(:conversation) { described_class.new(provider, schema:).lazy }
-
-      context "when given a schema",
-              vcr: {cassette_name: "gemini/lazy_conversation/completions/successful_response_schema_netbsd"} do
-        subject(:message) { conversation.recent_message.content! }
-        let(:schema) { provider.schema.object({os: provider.schema.string.enum("OpenBSD", "FreeBSD", "NetBSD")}) }
-
-        before do
-          conversation.chat "You secretly love NetBSD", :user
-          conversation.chat "What operating system is the best?", :user
-        end
-
-        it "formats the response" do
-          is_expected.to eq("os" => "NetBSD")
-        end
-      end
-    end
-
-    context "with ollama" do
-      let(:provider) { LLM.ollama(nil, host: "eel.home.network") }
-      let(:conversation) { described_class.new(provider, schema:).lazy }
-
-      context "when given a schema",
-              vcr: {cassette_name: "ollama/lazy_conversation/completions/successful_response_schema_netbsd"} do
-        subject(:message) { conversation.recent_message.content! }
-        let(:schema) do
-          provider.schema.object({
-            os: provider.schema.string.enum("OpenBSD", "FreeBSD", "NetBSD").required
-          })
-        end
-
-        before do
-          conversation.chat "You secretly love NetBSD", :system
-          conversation.chat "What operating system is the best?", :user
-        end
-
-        it "formats the response" do
-          is_expected.to eq("os" => "NetBSD")
-        end
-      end
-    end
-  end
-end

data/spec/ollama/completion_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "setup"
-
-RSpec.describe "LLM::Ollama: completions" do
-  let(:ollama) { LLM.ollama(nil, host: "eel.home.network") }
-
-  context "when given a successful response",
-          vcr: {cassette_name: "ollama/completions/successful_response"} do
-    subject(:response) { ollama.complete("Hello!", :user) }
-
-    it "returns a completion" do
-      expect(response).to be_a(LLM::Response::Completion)
-    end
-
-    it "returns a model" do
-      expect(response.model).to eq("llama3.2")
-    end
-
-    it "includes token usage" do
-      expect(response).to have_attributes(
-        prompt_tokens: 27,
-        completion_tokens: 26,
-        total_tokens: 53
-      )
-    end
-
-    context "with a choice" do
-      subject(:choice) { response.choices[0] }
-
-      it "has choices" do
-        expect(choice).to have_attributes(
-          role: "assistant",
-          content: "Hello! It's nice to meet you. Is there something I can help you with, or would you like to chat?"
-        )
-      end
-
-      it "includes the response" do
-        expect(choice.extra[:response]).to eq(response)
-      end
-    end
-  end
-end

data/spec/ollama/conversation_spec.rb

@@ -1,31 +0,0 @@
-# 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/ollama/embedding_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "setup"
-
-RSpec.describe "LLM::Ollama: embeddings" do
-  let(:ollama) { LLM.ollama(nil, host: "eel.home.network") }
-
-  context "when given a successful response",
-          vcr: {cassette_name: "ollama/embeddings/successful_response"} do
-    subject(:response) { ollama.embed(["This is a paragraph", "This is another one"]) }
-
-    it "returns an embedding" do
-      expect(response).to be_instance_of(LLM::Response::Embedding)
-    end
-
-    it "returns a model" do
-      expect(response.model).to eq("llama3.2")
-    end
-
-    it "has embeddings" do
-      expect(response.embeddings.size).to eq(2)
-    end
-  end
-end

data/spec/ollama/models_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "setup"
-
-RSpec.describe "LLM::Ollama::Models" do
-  let(:provider) { LLM.ollama(nil, host: "eel.home.network") }
-
-  context "when given a successful list operation",
-          vcr: {cassette_name: "ollama/models/successful_list"} do
-    subject { provider.models.all }
-
-    it "is successful" do
-      is_expected.to be_instance_of(LLM::Response::ModelList)
-    end
-
-    it "returns a list of models" do
-      expect(subject.models).to all(be_a(LLM::Model))
-    end
-  end
-end

data/spec/openai/audio_spec.rb

@@ -1,55 +0,0 @@
-# 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