Raise errors on HTTP errors or JSON parse errors

Author: atesgoral

lib/openai/http.rb

@@ -59,25 +59,21 @@ def to_json_stream(user_proc:)
 
       proc do |chunk, _bytes, env|
         if env && env.status != 200
-          emit_json(json: chunk, user_proc: user_proc)
-        else
-          parser.feed(chunk) do |_type, data|
-            emit_json(json: data, user_proc: user_proc) unless data == "[DONE]"
-          end
+          raise_error = Faraday::Response::RaiseError.new
+          raise_error.on_complete(env.merge(body: JSON.parse(chunk)))
         end
-      end
-    end
 
-    def emit_json(json:, user_proc:)
-      user_proc.call(JSON.parse(json))
-    rescue JSON::ParserError
-      # Ignore invalid JSON.
+        parser.feed(chunk) do |_type, data|
+          user_proc.call(JSON.parse(data)) unless data == "[DONE]"
+        end
+      end
     end
 
     def conn(multipart: false)
       Faraday.new do |f|
         f.options[:timeout] = @request_timeout
         f.request(:multipart) if multipart
+        f.response :raise_error
       end
     end
 

spec/fixtures/cassettes/gpt-3_5-turbo_streamed_chat_with_error_response.yml

@@ -72,6 +72,28 @@ def call(chunk)
               end
             end
           end
+
+          context "with an error response" do
+            let(:cassette) { "#{model} streamed chat with error response".downcase }
+
+            it "raises an HTTP error" do
+              VCR.use_cassette(cassette) do
+                response
+              rescue Faraday::BadRequestError => e
+                expect(e.response).to include(status: 400)
+                expect(e.response[:body]).to eq({
+                                                  "error" => {
+                                                    "message" => "Test error",
+                                                    "type" => "test_error",
+                                                    "param" => nil,
+                                                    "code" => "test"
+                                                  }
+                                                })
+              else
+                raise "Expected to raise Faraday::BadRequestError"
+              end
+            end
+          end
         end
       end
 

spec/openai/client/chat_spec.rb

@@ -81,9 +81,9 @@
 
       # It takes too long to fine-tune a model so we can delete it when running the test suite
       # against the live API. Instead, we just check that the API returns an error.
-      it "returns an error" do
+      it "raises an error" do
         VCR.use_cassette(cassette) do
-          expect(response.dig("error", "message")).to include("does not exist")
+          expect { response }.to raise_error(Faraday::ResourceNotFound)
         end
       end
 

spec/openai/client/finetunes_spec.rb

@@ -144,32 +144,12 @@
           CHUNK
         end
 
-        it "does not raise an error" do
+        it "raise an error" do
           expect(user_proc).to receive(:call).with(JSON.parse('{"foo": "bar"}'))
 
           expect do
             stream.call(chunk)
-          end.not_to raise_error
-        end
-      end
-
-      context "wehn called with string containing Obie's invalid JSON" do
-        let(:chunk) do
-          <<~CHUNK
-            data: { "foo": "bar" }
-
-            data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":123,"model":"gpt-4","choices":[{"index":0,"delta":{"role":"assistant","content":null,"fu
-
-            #
-          CHUNK
-        end
-
-        it "does not raise an error" do
-          expect(user_proc).to receive(:call).with(JSON.parse('{"foo": "bar"}'))
-
-          expect do
-            stream.call(chunk)
-          end.not_to raise_error
+          end.to raise_error(JSON::ParserError)
         end
       end