fix: Handle nil response in OpenAI LLM streaming (#953)

When using the `chat` method of `Langchain::LLM::OpenAI` with a block for streaming responses, the underlying `ruby-openai` client returns `nil` after the stream completes.

The `with_api_error_handling` method previously attempted to call
`.empty?` on this `nil` response, resulting in a `NoMethodError`.

This commit fixes the issue by adding a `response.nil? ||` check
before calling `.empty?` in `with_api_error_handling`. This prevents
the error when the client yields control back after finishing the stream.

Adds a new RSpec test case specifically for the streaming scenario. The test mocks the client to return `nil` after streaming and verifies that no error is raised and the final response object is correctly assembled from the collected chunks.

Author: sergiobayona

lib/langchain/llm/openai.rb

@@ -173,7 +173,7 @@ def reset_response_chunks
 
     def with_api_error_handling
       response = yield
-      return if response.empty?
+      return if response.nil? || response.empty?
 
       raise Langchain::LLM::ApiError.new "OpenAI API error: #{response.dig("error", "message")}" if response&.dig("error")
 

spec/langchain/llm/openai_spec.rb

@@ -619,6 +619,53 @@
       end
     end
 
+    context "when streaming with a block" do
+      let(:messages) { [{role: "user", content: "Tell me a joke"}] }
+      let(:stream_chunks) do
+        now = Time.now.to_i # Use a single timestamp for simplicity in the mock
+        model_name = "gpt-4o-mini" # Define model name once
+        chunk_id = "chatcmpl-stream-test" # Use a consistent ID
+
+        [
+          {"id" => chunk_id, "object" => "chat.completion.chunk", "created" => now, "model" => model_name, "choices" => [{"index" => 0, "delta" => {"role" => "assistant"}}]},
+          {"id" => chunk_id, "object" => "chat.completion.chunk", "created" => now, "model" => model_name, "choices" => [{"index" => 0, "delta" => {"content" => "Why did the chicken cross the road?"}}]},
+          {"id" => chunk_id, "object" => "chat.completion.chunk", "created" => now, "model" => model_name, "choices" => [{"index" => 0, "delta" => {}, "finish_reason" => "stop"}]},
+          {"id" => chunk_id, "object" => "chat.completion.chunk", "created" => now, "model" => model_name, "usage" => {"prompt_tokens" => 5, "completion_tokens" => 10, "total_tokens" => 15}}
+        ]
+      end
+      let(:collected_yielded_chunks) { [] }
+      let(:streaming_block) { proc { |chunk| collected_yielded_chunks << chunk } }
+      let(:expected_completion) { "Why did the chicken cross the road?" }
+
+      before do
+        allow(subject.client).to receive(:chat) do |parameters:|
+          expect(parameters[:stream]).to be_a(Proc)
+          expect(parameters[:stream_options]).to eq({include_usage: true})
+          stream_chunks.each { |chunk| parameters[:stream].call(chunk, chunk.to_json.bytesize) }
+          nil # Simulate nil return after streaming
+        end
+      end
+
+      it "does not raise NoMethodError and returns correctly assembled response" do
+        expect {
+          response = subject.chat(messages: messages, &streaming_block)
+          expect(response).to be_a(Langchain::LLM::OpenAIResponse)
+          expect(response.chat_completion).to eq(expected_completion)
+          expect(response.role).to eq("assistant")
+          expect(response.prompt_tokens).to eq(5)
+          expect(response.completion_tokens).to eq(10)
+          expect(response.total_tokens).to eq(15)
+        }.not_to raise_error
+      end
+
+      it "yields the processed delta chunks to the block" do
+        subject.chat(messages: messages, &streaming_block)
+        expected_yielded_chunks = stream_chunks.map { |c| c.dig("choices", 0) || {} }
+        expect(collected_yielded_chunks).to eq(expected_yielded_chunks)
+        expect(collected_yielded_chunks.map { |c| c.dig("delta", "content") }.compact.join).to eq(expected_completion)
+      end
+    end
+
     context "with streaming" do
       let(:streamed_response_chunk) do
         {