llm.rb 0.1.0 → 0.2.0

data/spec/anthropic/completion_spec.rb

@@ -3,29 +3,11 @@
 require "setup"
 
 RSpec.describe "LLM::Anthropic: completions" do
-  subject(:anthropic) { LLM.anthropic("") }
+  subject(:anthropic) { LLM.anthropic(token) }
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
 
-  before(:each, :success) do
-    stub_request(:post, "https://api.anthropic.com/v1/messages")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 200,
-        body: fixture("anthropic/completions/ok_completion.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
-
-  before(:each, :unauthorized) do
-    stub_request(:post, "https://api.anthropic.com/v1/messages")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 403,
-        body: fixture("anthropic/completions/unauthorized_completion.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
-
-  context "when given a successful response", :success do
+  context "when given a successful response",
+          vcr: {cassette_name: "anthropic/completions/successful_response"} do
     subject(:response) { anthropic.complete("Hello, world", :user) }
 
     it "returns a completion" do
@@ -38,9 +20,9 @@ RSpec.describe "LLM::Anthropic: completions" do
 
     it "includes token usage" do
       expect(response).to have_attributes(
-        prompt_tokens: 2095,
-        completion_tokens: 503,
-        total_tokens: 2598
+        prompt_tokens: 10,
+        completion_tokens: 30,
+        total_tokens: 40
       )
     end
 
@@ -50,7 +32,7 @@ RSpec.describe "LLM::Anthropic: completions" do
       it "has choices" do
         expect(choice).to have_attributes(
           role: "assistant",
-          content: "Hi! My name is Claude."
+          content: "Hello! How can I assist you today? Feel free to ask me any questions or let me know if you need help with anything."
         )
       end
 
@@ -60,8 +42,10 @@ RSpec.describe "LLM::Anthropic: completions" do
     end
   end
 
-  context "when given an unauthorized response", :unauthorized do
+  context "when given an unauthorized response",
+          vcr: {cassette_name: "anthropic/completions/unauthorized_response"} do
     subject(:response) { anthropic.complete("Hello", :user) }
+    let(:token) { "BADTOKEN" }
 
     it "raises an error" do
       expect { response }.to raise_error(LLM::Error::Unauthorized)

data/spec/anthropic/embedding_spec.rb

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

data/spec/gemini/completion_spec.rb

@@ -3,44 +3,26 @@
 require "setup"
 
 RSpec.describe "LLM::Gemini: completions" do
-  subject(:gemini) { LLM.gemini("") }
+  subject(:gemini) { LLM.gemini(token) }
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
 
-  before(:each, :success) do
-    stub_request(:post, "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 200,
-        body: fixture("gemini/completions/ok_completion.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
-
-  before(:each, :unauthorized) do
-    stub_request(:post, "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 400,
-        body: fixture("gemini/completions/unauthorized_completion.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
-
-  context "when given a successful response", :success do
-    subject(:response) { gemini.complete(LLM::Message.new("user", "Hello!")) }
+  context "when given a successful response",
+          vcr: {cassette_name: "gemini/completions/successful_response"} do
+    subject(:response) { gemini.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("gemini-1.5-flash-001")
+      expect(response.model).to eq("gemini-1.5-flash")
     end
 
     it "includes token usage" do
       expect(response).to have_attributes(
         prompt_tokens: 2,
-        completion_tokens: 10,
-        total_tokens: 12
+        completion_tokens: 11,
+        total_tokens: 13
       )
     end
 
@@ -52,7 +34,7 @@ RSpec.describe "LLM::Gemini: completions" do
           choices: [
             have_attributes(
               role: "model",
-              content: "Hello! How can I help you today? \n"
+              content: "Hello there! How can I help you today?\n"
             )
           ]
         )
@@ -64,8 +46,10 @@ RSpec.describe "LLM::Gemini: completions" do
     end
   end
 
-  context "when given an unauthorized response", :unauthorized do
-    subject(:response) { gemini.complete(LLM::Message.new("user", "Hello!")) }
+  context "when given an unauthorized response",
+          vcr: {cassette_name: "gemini/completions/unauthorized_response"} do
+    subject(:response) { gemini.complete("Hello!", :user) }
+    let(:token) { "BADTOKEN" }
 
     it "raises an error" do
       expect { response }.to raise_error(LLM::Error::Unauthorized)

data/spec/gemini/embedding_spec.rb

@@ -3,19 +3,11 @@
 require "setup"
 
 RSpec.describe "LLM::OpenAI: embeddings" do
-  let(:gemini) { LLM.gemini("") }
+  let(:gemini) { LLM.gemini(token) }
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
 
-  before(:each, :success) do
-    stub_request(:post, "https://generativelanguage.googleapis.com/v1beta/models/text-embedding-004:embedContent?key=")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 200,
-        body: fixture("gemini/embeddings/hello_world_embedding.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
-
-  context "when given a successful response", :success do
+  context "when given a successful response",
+          vcr: {cassette_name: "gemini/embeddings/successful_response"} do
     subject(:response) { gemini.embed("Hello, world") }
 
     it "returns an embedding" do

data/spec/llm/lazy_conversation_spec.rb

@@ -3,106 +3,88 @@
 require "setup"
 
 RSpec.describe LLM::LazyConversation do
-  context "with gemini" do
-    let(:provider) { LLM.gemini("") }
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
+  let(:prompt) { "Keep your answers short and concise, and provide three answers to the three questions" }
+
+  context "with gemini",
+          vcr: {cassette_name: "gemini/lazy_conversation/successful_response"} do
+    let(:provider) { LLM.gemini(token) }
     let(:conversation) { described_class.new(provider) }
 
     context "when given a thread of messages" do
       subject(:message) { conversation.messages.to_a[-1] }
 
       before do
-        stub_request(:post, "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=")
-          .with(
-            headers: {"Content-Type" => "application/json"},
-            body: request_fixture("gemini/completions/ok_completion.json")
-          )
-          .to_return(
-            status: 200,
-            body: response_fixture("gemini/completions/ok_completion.json"),
-            headers: {"Content-Type" => "application/json"}
-          )
-      end
-
-      before do
-        conversation.chat "Hello"
-        conversation.chat "I have a question"
-        conversation.chat "How are you?"
+        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
-        expect(message).to have_attributes(
+        is_expected.to have_attributes(
           role: "model",
-          content: "Hello! How can I help you today? \n"
+          content: "5\n10\n12\n"
         )
       end
     end
   end
 
-  context "with openai" do
-    let(:provider) { LLM.openai("") }
+  context "with openai"  do
+    let(:provider) { LLM.openai(token) }
     let(:conversation) { described_class.new(provider) }
 
-    context "when given a thread of messages" do
-      subject(:message) { conversation.messages.to_a[-1] }
-
-      before do
-        stub_request(:post, "https://api.openai.com/v1/chat/completions")
-          .with(
-            headers: {"Content-Type" => "application/json"},
-            body: request_fixture("openai/completions/ok_completion.json")
-          )
-          .to_return(
-            status: 200,
-            body: response_fixture("openai/completions/ok_completion.json"),
-            headers: {"Content-Type" => "application/json"}
-          )
-      end
+    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 "Hello"
-        conversation.chat "I have a question"
-        conversation.chat "How are you?"
+        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
-        expect(message).to have_attributes(
+        is_expected.to have_attributes(
           role: "assistant",
-          content: "Hello! How can I assist you today?"
+          content: "1. 5  \n2. 10  \n3. 12  "
         )
       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"]) }
+
+      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")
+      end
+    end
   end
 
-  context "with ollama" do
-    let(:provider) { LLM.ollama("") }
+  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) }
 
     context "when given a thread of messages" do
-      subject(:message) { conversation.messages.to_a[-1] }
-
-      before do
-        stub_request(:post, "http://localhost:11434/api/chat")
-          .with(
-            headers: {"Content-Type" => "application/json"},
-            body: request_fixture("ollama/completions/ok_completion.json")
-          )
-          .to_return(
-            status: 200,
-            body: response_fixture("ollama/completions/ok_completion.json"),
-            headers: {"Content-Type" => "application/json"}
-          )
-      end
+      subject(:message) { conversation.recent_message }
 
       before do
-        conversation.chat "Hello"
-        conversation.chat "I have a question"
-        conversation.chat "How are you?"
+        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
-        expect(message).to have_attributes(
+        is_expected.to have_attributes(
           role: "assistant",
-          content: "Hello! How are you today?"
+          content: "Here are the calculations:\n\n1. 3 + 2 = 5\n2. 5 + 5 = 10\n3. 5 + 7 = 12"
         )
       end
     end

data/spec/ollama/completion_spec.rb

@@ -3,19 +3,10 @@
 require "setup"
 
 RSpec.describe "LLM::Ollama: completions" do
-  subject(:ollama) { LLM.ollama("") }
-
-  before(:each, :success) do
-    stub_request(:post, "localhost:11434/api/chat")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 200,
-        body: fixture("ollama/completions/ok_completion.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
+  let(:ollama) { LLM.ollama(nil, host: "eel.home.network") }
 
-  context "when given a successful response", :success do
+  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
@@ -28,9 +19,9 @@ RSpec.describe "LLM::Ollama: completions" do
 
     it "includes token usage" do
       expect(response).to have_attributes(
-        prompt_tokens: 26,
-        completion_tokens: 298,
-        total_tokens: 324
+        prompt_tokens: 27,
+        completion_tokens: 26,
+        total_tokens: 53
       )
     end
 
@@ -40,7 +31,7 @@ RSpec.describe "LLM::Ollama: completions" do
       it "has choices" do
         expect(choice).to have_attributes(
           role: "assistant",
-          content: "Hello! How are you today?"
+          content: "Hello! It's nice to meet you. Is there something I can help you with, or would you like to chat?"
         )
       end
 

data/spec/ollama/embedding_spec.rb

@@ -3,13 +3,22 @@
 require "setup"
 
 RSpec.describe "LLM::Ollama: embeddings" do
-  let(:ollama) { LLM.ollama("") }
+  let(:ollama) { LLM.ollama(nil, host: "eel.home.network") }
 
-  context "when given a successful response", :success do
-    subject(:response) { ollama.embed("Hello, world") }
+  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 "raises NotImplementedError" do
-      expect { response }.to raise_error(NotImplementedError)
+    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/openai/completion_spec.rb

@@ -3,38 +3,11 @@
 require "setup"
 
 RSpec.describe "LLM::OpenAI: completions" do
-  subject(:openai) { LLM.openai("") }
+  subject(:openai) { LLM.openai(token) }
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
 
-  before(:each, :success) do
-    stub_request(:post, "https://api.openai.com/v1/chat/completions")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 200,
-        body: fixture("openai/completions/ok_completion.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
-
-  before(:each, :unauthorized) do
-    stub_request(:post, "https://api.openai.com/v1/chat/completions")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 401,
-        body: fixture("openai/completions/unauthorized_completion.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
-
-  before(:each, :bad_request) do
-    stub_request(:post, "https://api.openai.com/v1/chat/completions")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 400,
-        body: fixture("openai/completions/badrequest_completion.json")
-      )
-  end
-
-  context "when given a successful response", :success do
+  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
@@ -48,8 +21,8 @@ RSpec.describe "LLM::OpenAI: completions" do
     it "includes token usage" do
       expect(response).to have_attributes(
         prompt_tokens: 9,
-        completion_tokens: 9,
-        total_tokens: 18
+        completion_tokens: 10,
+        total_tokens: 19
       )
     end
 
@@ -69,31 +42,34 @@ RSpec.describe "LLM::OpenAI: completions" do
     end
   end
 
-  context "when given an unauthorized response", :unauthorized do
-    subject(:response) { openai.complete(LLM::Message.new("Hello!", :user)) }
+  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::Unauthorized)
+      expect { response }.to raise_error(LLM::Error::BadResponse)
     end
 
     it "includes the response" do
       response
-    rescue LLM::Error::Unauthorized => ex
-      expect(ex.response).to be_kind_of(Net::HTTPResponse)
+    rescue LLM::Error => ex
+      expect(ex.response).to be_instance_of(Net::HTTPBadRequest)
     end
   end
 
-  context "when given a 'bad request' response", :bad_request do
-    subject(:response) { openai.complete(URI("/foobar.exe"), :user) }
+  context "when given an unauthorized response",
+          vcr: {cassette_name: "openai/completions/unauthorized_response"} do
+    subject(:response) { openai.complete(LLM::Message.new("Hello!", :user)) }
+    let(:token) { "BADTOKEN" }
 
     it "raises an error" do
-      expect { response }.to raise_error(LLM::Error::BadResponse)
+      expect { response }.to raise_error(LLM::Error::Unauthorized)
     end
 
     it "includes the response" do
       response
-    rescue LLM::Error => ex
-      expect(ex.response).to be_instance_of(Net::HTTPBadRequest)
+    rescue LLM::Error::Unauthorized => ex
+      expect(ex.response).to be_kind_of(Net::HTTPResponse)
     end
   end
 end

data/spec/openai/embedding_spec.rb

@@ -3,19 +3,11 @@
 require "setup"
 
 RSpec.describe "LLM::OpenAI: embeddings" do
-  let(:openai) { LLM.openai("") }
+  let(:openai) { LLM.openai(token) }
+  let(:token) { ENV["LLM_SECRET"] || "TOKEN" }
 
-  before(:each, :success) do
-    stub_request(:post, "https://api.openai.com/v1/embeddings")
-      .with(headers: {"Content-Type" => "application/json"})
-      .to_return(
-        status: 200,
-        body: fixture("openai/embeddings/hello_world_embedding.json"),
-        headers: {"Content-Type" => "application/json"}
-      )
-  end
-
-  context "when given a successful response", :success do
+  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

data/spec/readme_spec.rb

@@ -22,22 +22,19 @@ RSpec.describe "The README examples" do
 
     let(:expected_conversation) do
       [
-        "[system] You are a friendly chatbot. Sometimes, you like to tell a joke.",
-        "But the joke must be based on the given inputs.",
+        "[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] What color is the sky?",
-        "[user] What color is an orange?",
-        "[user] I like Ruby",
+        "[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 sky is typically blue during the day, but it can have beautiful",
-        "hues of pink, orange, and purple during sunset! As for an orange,",
-        "it's typically orange in color - funny how that works, right?",
-        "I love Ruby too! Did you know that a Ruby is not only a beautiful",
-        "gemstone, but it's also a programming language that's both elegant",
-        "and powerful! Speaking of colors, why did the orange stop?",
-        "Because it ran out of juice!"
+        "[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
 

data/spec/setup.rb

@@ -2,6 +2,7 @@
 
 require "llm"
 require "webmock/rspec"
+require "vcr"
 
 RSpec.configure do |config|
   config.disable_monkey_patching!
@@ -9,21 +10,11 @@ RSpec.configure do |config|
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
+end
 
-  config.include Module.new {
-    def request_fixture(file)
-      path = File.join(fixtures, "requests", file)
-      File.read(path).chomp
-    end
-
-    def response_fixture(file)
-      path = File.join(fixtures, "responses", file)
-      File.read(path).chomp
-    end
-    alias_method :fixture, :response_fixture
-
-    def fixtures
-      File.join(__dir__, "fixtures")
-    end
-  }
+VCR.configure do |config|
+  config.cassette_library_dir = "spec/fixtures/cassettes"
+  config.hook_into :webmock
+  config.configure_rspec_metadata!
+  config.filter_sensitive_data("TOKEN") { ENV["LLM_SECRET"] }
 end