llm.rb 0.4.0 → 0.4.1

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

data/spec/openai/completion_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require "setup"
-
-RSpec.describe "LLM::OpenAI: completions" do
-  subject(:openai) { LLM.openai(token) }
-  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
-
-  context "when given a successful response",
-          vcr: {cassette_name: "openai/completions/successful_response"} do
-    subject(:response) { openai.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("gpt-4o-mini-2024-07-18")
-    end
-
-    it "includes token usage" do
-      expect(response).to have_attributes(
-        prompt_tokens: 9,
-        completion_tokens: 10,
-        total_tokens: 19
-      )
-    end
-
-    context "with a choice" do
-      subject(:choice) { response.choices[0] }
-
-      it "has choices" do
-        expect(choice).to have_attributes(
-          role: "assistant",
-          content: "Hello! How can I assist you today?"
-        )
-      end
-
-      it "includes the response" do
-        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: "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
-
-    it "has choices" do
-      expect(response).to have_attributes(
-        choices: [
-          have_attributes(
-            role: "assistant",
-            content: %r|\AMy name is Pablo and I am 25 years old|
-          )
-        ]
-      )
-    end
-  end
-
-  context "when asked to describe an audio file",
-          vcr: {cassette_name: "openai/completions/describe_pdf_document"} do
-    let(:file) { LLM::File("spec/fixtures/documents/freebsd.sysctl.pdf") }
-    let(:response) do
-      openai.complete([
-        "This PDF document describes sysctl nodes on FreeBSD",
-        "Answer yes or no.",
-        "Nothing else",
-        file
-      ], :user)
-    end
-
-    subject { response.choices[0].content.downcase[0..2] }
-
-    it "is successful" do
-      is_expected.to eq("yes")
-    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) }
-
-    it "raises an error" do
-      expect { response }.to raise_error(LLM::Error::ResponseError)
-    end
-
-    it "includes the response" do
-      response
-    rescue LLM::Error => ex
-      expect(ex.response).to be_instance_of(Net::HTTPBadRequest)
-    end
-  end
-
-  context "when given an unauthorized response",
-          vcr: {cassette_name: "openai/completions/unauthorized_response"} do
-    subject(:response) { openai.complete(LLM::Message.new(:user, "Hello!")) }
-    let(:token) { "BADTOKEN" }
-
-    it "raises an error" do
-      expect { response }.to raise_error(LLM::Error::Unauthorized)
-    end
-
-    it "includes the response" do
-      response
-    rescue LLM::Error::Unauthorized => ex
-      expect(ex.response).to be_kind_of(Net::HTTPResponse)
-    end
-  end
-end

data/spec/openai/embedding_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "setup"
-
-RSpec.describe "LLM::OpenAI: embeddings" do
-  let(:openai) { LLM.openai(token) }
-  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
-
-  context "when given a successful response",
-          vcr: {cassette_name: "openai/embeddings/successful_response"} do
-    subject(:response) { openai.embed("Hello, world") }
-
-    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("text-embedding-3-small")
-    end
-
-    it "has embeddings" do
-      expect(response.embeddings).to be_instance_of(Array)
-    end
-  end
-end