llm.rb 0.4.0 → 0.4.2

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

data/spec/openai/files_spec.rb

@@ -1,204 +0,0 @@
-# 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(:filelist) { provider.files.all }
-
-    it "is successful" do
-      expect(filelist).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(filelist.files[0..1]).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

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "setup"
-
-RSpec.describe "LLM::OpenAI::Models" do
-  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
-  let(:provider) { LLM.openai(token) }
-
-  context "when given a successful list operation",
-          vcr: {cassette_name: "openai/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/responses_spec.rb

@@ -1,51 +0,0 @@
-# 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/readme_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "setup"
-require "test/cmd"
-
-RSpec.describe "The README examples" do
-  before { ENV["key"] = key }
-  after { ENV["key"] = nil }
-  let(:key) { "" }
-
-  context "when given the lazy conversation example" do
-    subject(:command) do
-      cmd RbConfig.ruby,
-        "-Ilib",
-        "-r", webmock("lazy_conversation.rb"),
-        readme_example("lazy_conversation.rb")
-    end
-
-    let(:actual_conversation) do
-      command.stdout.each_line.map(&:strip)
-    end
-
-    let(:expected_conversation) do
-      [
-        "[system] You are my math assistant.",
-        "I will provide you with (simple) equations.",
-        "You will provide answers in the format \"The answer to <equation> is <answer>\".",
-        "I will provide you a set of messages. Reply to all of them.",
-        "A message is considered unanswered if there is no corresponding assistant response.",
-
-        "[user] Tell me the answer to 5 + 15",
-        "[user] Tell me the answer to (5 + 15) * 2",
-        "[user] Tell me the answer to ((5 + 15) * 2) / 10",
-
-        "[assistant] The answer to 5 + 15 is 20.",
-        "The answer to (5 + 15) * 2 is 40.",
-        "The answer to ((5 + 15) * 2) / 10 is 4."
-      ].map(&:strip)
-    end
-
-    it "is successful" do
-      is_expected.to be_success
-    end
-
-    it "emits output" do
-      expect(join(actual_conversation)).to eq(join(expected_conversation))
-    end
-  end
-
-  def webmock(example)
-    File.join(Dir.getwd, "share", "llm", "webmocks", example)
-  end
-
-  def readme_example(example)
-    File.join(Dir.getwd, "share", "llm", "examples", example)
-  end
-
-  def join(lines)
-    lines.reject(&:empty?).join("\n")
-  end
-end

data/spec/setup.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "llm"
-require "webmock/rspec"
-require "vcr"
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end
-
-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