ai-lite 0.6.1 → 1.1.0

data/test/gemini_embeddings_test.rb

@@ -0,0 +1,122 @@
+require_relative "test_helper"
+
+class GeminiEmbeddingsTest < Minitest::Test
+  Response = Struct.new(:code, :body)
+  class Http
+    attr_accessor :open_timeout, :read_timeout
+    attr_reader :request_received
+    def initialize(response)
+      @response = response
+    end
+    def request(request)
+      @request_received = request
+      raise @response if @response.is_a?(Exception)
+      @response
+    end
+  end
+
+  def setup
+    AiLite::Gemini.reset_configuration!
+    AiLite::OpenAI.reset_configuration!
+    @client = AiLite::Gemini.new(api_key: "gemini-key", timeout: 9)
+  end
+
+  def with_http(raw = {}, status = "200")
+    response = raw.is_a?(Exception) ? raw : Response.new(status, raw.is_a?(String) ? raw : JSON.generate(raw))
+    http = Http.new(response)
+    original = Net::HTTP.method(:start)
+    Net::HTTP.define_singleton_method(:start) do |host, port, use_ssl:, &block|
+      raise "Wrong provider host" unless host == "generativelanguage.googleapis.com" && port == 443 && use_ssl
+      block.call(http)
+    end
+    yield http
+  ensure
+    Net::HTTP.define_singleton_method(:start, original)
+  end
+
+  def test_single_embedding_transport_and_envelope
+    with_http({ "embedding" => { "values" => [0.1, -0.2] } }) do |http|
+      result = @client.embed("Hello")
+      assert_equal({ "content" => [0.1, -0.2], "status" => 200, "error" => nil,
+                     "raw" => nil, "response_id" => nil }, result)
+      assert_equal "/v1beta/models/gemini-embedding-001:embedContent", http.request_received.path
+      assert_equal "gemini-key", http.request_received["x-goog-api-key"]
+      assert_equal "application/json", http.request_received["Content-Type"]
+      assert_equal 9, http.read_timeout
+      assert_equal 9, http.open_timeout
+      assert_equal({ "model" => "models/gemini-embedding-001", "content" => { "parts" => [{ "text" => "Hello" }] } }, JSON.parse(http.request_received.body))
+    end
+  end
+
+  def test_batch_order_options_dimensions_and_debug
+    options = { taskType: "RETRIEVAL_DOCUMENT", title: "Guide", "outputDimensionality" => 8 }
+    original = Marshal.dump(options)
+    raw = { "embeddings" => [{ "values" => [1, 2] }, { "values" => [3, 4] }], "usageMetadata" => { "totalTokenCount" => 4 } }
+    with_http(raw) do |http|
+      result = @client.embed(["First", "Second"], model: "models/custom", dimensions: 2, encoding_format: "float", options: options, debug: true)
+      assert_equal [[1, 2], [3, 4]], result["content"]
+      assert_equal raw, result["raw"]
+      assert_equal "/v1beta/models/custom:batchEmbedContents", http.request_received.path
+      requests = JSON.parse(http.request_received.body)["requests"]
+      assert_equal ["First", "Second"], requests.map { |r| r.dig("content", "parts", 0, "text") }
+      requests.each do |request|
+        assert_equal "models/custom", request["model"]
+        assert_equal 2, request["outputDimensionality"]
+        assert_equal "RETRIEVAL_DOCUMENT", request["taskType"]
+        assert_equal "Guide", request["title"]
+        refute request.key?("encoding_format")
+      end
+      assert_equal original, Marshal.dump(options)
+    end
+    with_http({ "embeddings" => [{ "values" => [1] }] }) do
+      assert_equal [[1]], @client.embed(["Only one"])["content"]
+    end
+  end
+
+  def test_configuration_delegation_and_model_checks
+    AiLite::Gemini.configure { |c| c.api_key = "key"; c.embedding_model = "configured" }
+    assert_equal "configured", AiLite::Gemini.client.embedding_model
+    assert_equal "gemini-embedding-001", @client.embedding_model
+    assert_equal "override", AiLite::Gemini.new(embedding_model: "override").embedding_model
+    snapshot = AiLite::Gemini.configured_models
+    snapshot["embedding"].replace("changed")
+    assert_equal "configured", AiLite::Gemini.configuration.embedding_model
+    with_http({ "embedding" => { "values" => [1] } }) do |http|
+      assert_equal [1], AiLite::Gemini.embed("Hello")["content"]
+      assert_equal "/v1beta/models/configured:embedContent", http.request_received.path
+    end
+    with_http({ "models" => [{ "name" => "models/configured" }] }) do
+      assert_equal true, AiLite::Gemini.check_configured_models.dig("content", "embedding", "available")
+    end
+  end
+
+  def test_invalid_inputs_do_not_make_requests
+    with_http do |http|
+      [nil, [], "", ["ok", nil], { text: "hi" }].each { |input| refute_nil @client.embed(input)["error"] }
+      [{ dimensions: 0 }, { dimensions: "2" }, { encoding_format: "base64" }, { model: "bad/path" }].each do |kwargs|
+        refute_nil @client.embed("Hello", **kwargs)["error"]
+      end
+      assert_nil http.request_received
+    end
+  end
+
+  def test_api_transport_and_malformed_response_errors
+    with_http({ "error" => { "message" => "Denied" } }, "403") do
+      result = @client.embed("Hello", debug: true)
+      assert_equal 403, result["status"]
+      assert_equal "Denied", result["error"]
+      refute_nil result["raw"]
+    end
+    ["invalid json", [], {}, { "embedding" => { "values" => ["bad"] } }, IOError.new("Disconnected")].each do |raw|
+      with_http(raw) do
+        result = @client.embed("Hello")
+        refute_nil result["error"]
+        assert_nil result["content"]
+        assert_nil result["raw"]
+      end
+    end
+    with_http({ "embeddings" => [{ "values" => [1] }] }) do
+      assert_match(/count/, @client.embed(["one", "two"])["error"])
+    end
+  end
+end

data/test/gemini_images_test.rb

@@ -0,0 +1,154 @@
+require_relative "test_helper"
+require "tmpdir"
+
+class GeminiImagesTest < Minitest::Test
+  Response = Struct.new(:code, :body)
+  class Http
+    attr_accessor :open_timeout, :read_timeout
+    attr_reader :request_received
+    def initialize(response)
+      @response = response
+    end
+    def request(request)
+      @request_received = request
+      raise @response if @response.is_a?(Exception)
+      @response
+    end
+  end
+
+  def setup
+    AiLite::Gemini.reset_configuration!
+    AiLite::OpenAI.reset_configuration!
+    @client = AiLite::Gemini.new(api_key: "gemini-key", timeout: 9)
+  end
+
+  def with_http(raw = {}, status = "200")
+    response = raw.is_a?(Exception) ? raw : Response.new(status, raw.is_a?(String) ? raw : JSON.generate(raw))
+    http = Http.new(response)
+    original = Net::HTTP.method(:start)
+    Net::HTTP.define_singleton_method(:start) do |host, port, use_ssl:, &block|
+      raise "Wrong provider host" unless host == "generativelanguage.googleapis.com" && port == 443 && use_ssl
+      block.call(http)
+    end
+    yield http
+  ensure
+    Net::HTTP.define_singleton_method(:start, original)
+  end
+
+  PNG = Base64.strict_decode64("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aX1sAAAAASUVORK5CYII=")
+
+  def image_body
+    { "id" => "image-123", "status" => "completed", "steps" => [
+      { "type" => "thought", "content" => [{ "type" => "image", "data" => Base64.strict_encode64("hidden") }] },
+      { "type" => "model_output", "content" => [
+        { "type" => "text", "text" => "Here is your image" },
+        { "type" => "image", "mime_type" => "image/png", "data" => Base64.strict_encode64(PNG) },
+        { "type" => "image", "mime_type" => "image/png", "data" => Base64.strict_encode64("second") }
+      ] }
+    ] }
+  end
+
+  def test_default_transport_first_image_and_envelope
+    with_http(image_body) do |http|
+      result = @client.image("A cat")
+      assert_equal({ "content" => Base64.strict_encode64(PNG), "status" => 200,
+                     "error" => nil, "response_id" => "image-123", "raw" => nil }, result)
+      request = http.request_received
+      assert_equal "/v1beta/interactions", request.path
+      assert_equal "gemini-key", request["x-goog-api-key"]
+      assert_equal "application/json", request["Content-Type"]
+      assert_equal({ "model" => AiLite::Gemini::DEFAULT_IMAGE_MODEL, "input" => "A cat" }, JSON.parse(request.body))
+      assert_equal 9, http.open_timeout
+      assert_equal 9, http.read_timeout
+    end
+  end
+
+  def test_native_options_precedence_debug_and_file_output
+    options = { model: "ignored", "input" => "ignored", response_format: { type: "image", aspect_ratio: "16:9", image_size: "2K" }, store: false }
+    original = Marshal.dump(options)
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "cat.png")
+      with_http(image_body) do |http|
+        result = @client.image("A cat", model: "custom-image", output_path: path, options: options, debug: true)
+        assert_nil result["error"]
+        assert_equal PNG, File.binread(path)
+        assert_equal Base64.strict_encode64(PNG), result["content"]
+        assert_equal image_body, result["raw"]
+        payload = JSON.parse(http.request_received.body)
+        assert_equal "custom-image", payload["model"]
+        assert_equal "A cat", payload["input"]
+        assert_equal false, payload["store"]
+        assert_equal "16:9", payload.dig("response_format", "aspect_ratio")
+        assert_equal "2K", payload.dig("response_format", "image_size")
+        refute payload.key?("generation_config")
+      end
+    end
+    assert_equal original, Marshal.dump(options)
+  end
+
+  def test_configuration_delegation_and_model_checks
+    AiLite::Gemini.configure { |c| c.api_key = "key"; c.image_model = "configured-image" }
+    assert_equal "configured-image", AiLite::Gemini.client.image_model
+    assert_equal AiLite::Gemini::DEFAULT_IMAGE_MODEL, @client.image_model
+    assert_equal "override", AiLite::Gemini.new(image_model: "override").image_model
+    original = AiLite::OpenAI.configured_models
+    snapshot = AiLite::Gemini.configured_models
+    snapshot["image"].replace("changed")
+    assert_equal "configured-image", AiLite::Gemini.configuration.image_model
+    with_http(image_body) do |http|
+      assert_nil AiLite::Gemini.image("A cat")["error"]
+      assert_equal "configured-image", JSON.parse(http.request_received.body)["model"]
+    end
+    with_http({ "models" => [{ "name" => "models/configured-image" }] }) do
+      assert_equal true, AiLite::Gemini.check_configured_models.dig("content", "image", "available")
+    end
+    assert_equal original, AiLite::OpenAI.configured_models
+  end
+
+  def test_invalid_inputs_and_execution_modes_do_not_send_requests
+    with_http do |http|
+      [nil, " ", [], {}].each { |prompt| refute_nil @client.image(prompt)["error"] }
+      [{ stream: true }, { "background" => true }].each do |options|
+        refute_nil @client.image("A cat", options: options)["error"]
+      end
+      assert_nil http.request_received
+    end
+  end
+
+  def test_errors_do_not_overwrite_output
+    malformed = image_body
+    malformed["steps"][1]["content"][1]["data"] = "invalid base64!"
+    no_image = image_body.merge("steps" => [{ "type" => "model_output", "content" => [{ "type" => "text", "text" => "Cannot generate" }] }])
+    responses = [malformed, no_image, "invalid JSON", [], {}, IOError.new("Disconnected")]
+    %w[failed incomplete cancelled requires_action queued in_progress].each do |state|
+      responses << image_body.merge("status" => state)
+    end
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "existing.png")
+      File.binwrite(path, "original")
+      responses.each do |raw|
+        with_http(raw) do
+          result = @client.image("A cat", output_path: path)
+          refute_nil result["error"]
+          assert_nil result["content"]
+          assert_nil result["raw"]
+          assert_equal "original", File.binread(path)
+        end
+      end
+      with_http(image_body) do
+        result = @client.image("A cat", output_path: File.join(dir, "missing", "cat.png"), debug: true)
+        refute_nil result["error"]
+        assert_equal "image-123", result["response_id"]
+        assert_equal image_body, result["raw"]
+      end
+    end
+    ["403", "200"].each do |status|
+      with_http({ "error" => { "message" => "Denied" } }, status) do
+        result = @client.image("A cat", debug: true)
+        assert_equal "Denied", result["error"]
+        assert_equal status.to_i, result["status"]
+        refute_nil result["raw"]
+      end
+    end
+  end
+end

data/test/gemini_models_test.rb

@@ -0,0 +1,113 @@
+require_relative "test_helper"
+
+class GeminiModelsTest < Minitest::Test
+  Response = Struct.new(:code, :body)
+  class Http
+    attr_accessor :open_timeout, :read_timeout
+    attr_reader :requests
+    def initialize(pages)
+      @pages, @requests = pages, []
+    end
+    def request(request)
+      @requests << request
+      page = @pages.shift
+      raise page if page.is_a?(Exception)
+      raise "Unexpected request" unless page
+      Response.new(page[0], page[1].is_a?(String) ? page[1] : JSON.generate(page[1]))
+    end
+  end
+  def setup
+    AiLite::Gemini.reset_configuration!
+    @client = AiLite::Gemini.new(api_key: "key", model: "models/test-model", timeout: 7)
+  end
+  def with_pages(*pages)
+    http = Http.new(pages)
+    original = Net::HTTP.method(:start)
+    Net::HTTP.define_singleton_method(:start) do |host, port, use_ssl:, &block|
+      raise "Wrong host" unless host == "generativelanguage.googleapis.com" && port == 443 && use_ssl
+      block.call(http)
+    end
+    yield http
+  ensure
+    Net::HTTP.define_singleton_method(:start, original)
+  end
+  def page(names, token = nil)
+    result = { "models" => names.map { |id| { "name" => "models/#{id}", "supportedGenerationMethods" => ["generateContent"] } } }
+    result["nextPageToken"] = token if token
+    ["200", result]
+  end
+  def test_pagination_normalization_metadata_and_http
+    with_pages(page(["first"], "a+b/&="), page(["test-model", "first"])) do |http|
+      result = @client.available_models(debug: true)
+      assert_equal ["first", "test-model"], result["content"]
+      assert_nil result["error"]
+      assert_equal 2, result.dig("raw", "pages").size
+      assert_equal ["generateContent"], result.dig("raw", "pages", 0, "models", 0, "supportedGenerationMethods")
+      assert_equal 2, http.requests.size
+      assert_equal "/v1beta/models", http.requests[0].path
+      request = http.requests[1]
+      assert_instance_of Net::HTTP::Get, request
+      assert_equal [["pageToken", "a+b/&="]], URI.decode_www_form(URI(request.path).query)
+      assert_equal "key", request["x-goog-api-key"]
+      assert_nil request["Authorization"]
+      assert_nil request.body
+      assert_equal 7, http.read_timeout
+      assert_equal 7, http.open_timeout
+    end
+  end
+  def test_predicate_matches_exact_ids_with_optional_resource_prefix
+    { "test-model" => true, "models/test-model" => true, "test" => false, "TEST-MODEL" => false }.each do |name, expected|
+      with_pages(page(["test-model"])) { assert_equal expected, @client.model_available?(name) }
+    end
+    [nil, "", " ", :test].each { |name| assert_raises(ArgumentError) { @client.model_available?(name) } }
+    with_pages(["200", {}]) { assert_equal [], @client.available_models["content"] }
+    with_pages(page([])) { assert_equal false, @client.model_available?("missing") }
+  end
+  def test_local_configuration_and_single_paginated_check
+    with_pages do |http|
+      assert_equal({ "chat" => AiLite::Gemini::DEFAULT_MODEL, "embedding" => AiLite::Gemini::DEFAULT_EMBEDDING_MODEL, "image" => AiLite::Gemini::DEFAULT_IMAGE_MODEL }, AiLite::Gemini.configured_models)
+      snapshot = @client.configured_models
+      snapshot["chat"].replace("changed")
+      assert_equal "models/test-model", @client.model
+      assert_empty http.requests
+    end
+    with_pages(page(["other"], "next"), page(["test-model"])) do |http|
+      result = @client.check_configured_models
+      assert_equal 2, http.requests.size
+      assert_equal({ "chat" => { "model" => "models/test-model", "usage" => "chat", "available" => true, "error" => nil } }, result["content"].slice("chat"))
+      assert_equal false, result.dig("content", "embedding", "available")
+      assert_nil result["raw"]
+    end
+  end
+  def test_failed_later_pages_do_not_return_partial_success
+    [["200", { "error" => { "message" => "Unexpected error" } }], ["403", { "error" => { "message" => "Denied" } }], ["200", "invalid"],
+     ["200", { "models" => [{}] }], ["200", []], ["200", { "nextPageToken" => 3 }],
+     IOError.new("Disconnected")].each do |failure|
+      with_pages(page(["test-model"], "next"), failure) do
+        result = @client.available_models(debug: true)
+        assert_nil result["content"]
+        refute_nil result["error"]
+        refute_empty result.dig("raw", "pages")
+      end
+      with_pages(failure) { assert_nil @client.model_available?("test-model") }
+      with_pages(failure) do
+        result = @client.check_configured_models
+        assert_nil result.dig("content", "chat", "available")
+        refute_nil result["error"]
+        assert_equal result["error"], result.dig("content", "chat", "error")
+      end
+    end
+    with_pages(page([], "same"), page([], "same")) do |http|
+      assert_match(/Repeated/, @client.available_models["error"])
+      assert_equal 2, http.requests.size
+    end
+  end
+  def test_class_delegation_and_provider_isolation
+    AiLite::Gemini.configure { |c| c.api_key = "key"; c.model = "test-model" }
+    original = AiLite::OpenAI.configured_models
+    with_pages(page(["test-model"])) { assert_equal ["test-model"], AiLite::Gemini.available_models["content"] }
+    with_pages(page(["test-model"])) { assert_equal true, AiLite::Gemini.model_available?("test-model") }
+    with_pages(page([])) { assert_equal false, AiLite::Gemini.check_configured_models.dig("content", "chat", "available") }
+    assert_equal original, AiLite::OpenAI.configured_models
+  end
+end

data/test/gemini_streaming_test.rb

@@ -0,0 +1,166 @@
+require_relative "test_helper"
+
+class GeminiStreamingTest < Minitest::Test
+  class Response
+    attr_reader :code, :read_count
+    def initialize(chunks, code)
+      @chunks, @code, @read_count = chunks, code, 0
+    end
+    def read_body
+      @chunks.each do |chunk|
+        raise chunk if chunk.is_a?(Exception)
+        @read_count += 1
+        yield chunk
+      end
+    end
+  end
+  class Http
+    attr_accessor :open_timeout, :read_timeout
+    attr_reader :request_received
+    def initialize(response)
+      @response = response
+    end
+    def request(request)
+      @request_received = request
+      yield @response
+    end
+  end
+  def setup
+    AiLite::Gemini.reset_configuration!
+    @client = AiLite::Gemini.new(api_key: "test-key", timeout: 8)
+  end
+  def event(type, fields = {})
+    "data: #{JSON.generate(fields.merge('event_type' => type))}\n\n"
+  end
+  def start
+    event("interaction.created", "interaction" => { "id" => "stream-id", "status" => "in_progress" }) +
+      event("step.start", "index" => 0, "step" => { "type" => "model_output" })
+  end
+  def delta(text, index = 0)
+    event("step.delta", "index" => index, "delta" => { "type" => "text", "text" => text })
+  end
+  def finish(status = "completed")
+    event("interaction.completed", "interaction" => { "id" => "stream-id", "status" => status, "usage" => { "total_tokens" => 4 } })
+  end
+  def with_http(chunks, code = "200")
+    response = Response.new(chunks, code)
+    http = Http.new(response)
+    original = Net::HTTP.method(:start)
+    Net::HTTP.define_singleton_method(:start) do |host, port, use_ssl:, &block|
+      raise "Wrong provider" unless host == "generativelanguage.googleapis.com" && port == 443 && use_ssl
+      block.call(http)
+    end
+    yield http, response
+  ensure
+    Net::HTTP.define_singleton_method(:start, original)
+  end
+  def test_incremental_delivery_request_options_and_partial_terminal_resource
+    options = { "stream" => false, generation_config: { temperature: 0.2 } }
+    original = Marshal.dump(options)
+    with_http([start, delta("Hi"), delta(" there"), finish]) do |http, response|
+      pieces = []
+      result = @client.chat_stream([{ type: "text", text: "Hello" }], model: "custom-model",
+        instructions: "Brief", previous_response_id: "previous", max_output_tokens: 50,
+        options: options, debug: true) do |text|
+        pieces << text
+        assert_equal pieces.size + 1, response.read_count
+      end
+      assert_equal ["Hi", " there"], pieces
+      assert_equal "Hi there", result["content"]
+      assert_equal "stream-id", result["response_id"]
+      assert_nil result["error"]
+      assert_equal 4, result.dig("raw", "interaction", "usage", "total_tokens")
+      assert_equal 5, result["raw"]["events"].size
+      request = http.request_received
+      assert_equal "/v1beta/interactions", request.path
+      assert_equal "test-key", request["x-goog-api-key"]
+      assert_nil request["Authorization"]
+      assert_equal "text/event-stream", request["Accept"]
+      payload = JSON.parse(request.body)
+      assert_equal true, payload["stream"]
+      assert_equal "previous", payload["previous_interaction_id"]
+      assert_equal "Brief", payload["system_instruction"]
+      assert_equal "custom-model", payload["model"]
+      assert_equal 50, payload.dig("generation_config", "max_output_tokens")
+      assert_equal 0.2, payload.dig("generation_config", "temperature")
+      assert_equal 8, http.read_timeout
+      assert_equal 8, http.open_timeout
+      assert_equal original, Marshal.dump(options)
+    end
+  end
+  def test_fragmented_utf8_multiline_sse_and_reasoning_filter
+    stream = ": heartbeat\r\n\r\n" + start +
+      event("step.start", "index" => 1, "step" => { "type" => "thought" }) + delta("Secret", 1) +
+      "data: {\"event_type\":\"step.delta\",\r\ndata: \"index\":0,\"delta\":{\"type\":\"text\",\"text\":\"🌍\"}}\r\n\r\n" +
+      event("step.stop", "index" => 0) + finish
+    with_http(stream.bytes.map(&:chr)) do
+      parts = []
+      result = @client.chat_stream("Hello") { |text| parts << text }
+      assert_equal ["🌍"], parts
+      assert_equal "🌍", result["content"]
+      assert_nil result["raw"]
+      assert_nil result["error"]
+    end
+  end
+  def test_json_and_class_delegation
+    AiLite::Gemini.configure { |c| c.api_key = "key" }
+    with_http([start + delta('{"ok":true}') + finish]) do
+      result = AiLite::Gemini.chat_stream("JSON") { |_| }
+      assert_equal({ "ok" => true }, result["content"])
+    end
+  end
+  def test_failure_events_and_interrupted_streams
+    tails = [finish("incomplete"), finish("failed"), finish("requires_action"),
+      event("interaction.status_update", "status" => "cancelled"),
+      event("error", "error" => { "message" => "Overloaded" }),
+      "data: [DONE]\n\n", "data: {broken}\n\n", "data: {", IOError.new("Disconnected")]
+    tails.each do |tail|
+      with_http([start, delta("Partial"), tail]) do
+        result = @client.chat_stream("Hi", debug: true) { |_| }
+        assert_equal "Partial", result["content"]
+        assert_equal "stream-id", result["response_id"]
+        refute_nil result["error"]
+        refute_nil result["raw"]
+      end
+    end
+    with_http([start]) do
+      assert_match(/terminal/, @client.chat_stream("Hi") { |_| }["error"])
+    end
+  end
+  def test_http_errors_and_block_exceptions
+    with_http(['{"error":{"message":"Denied"}}'], "403") do
+      result = @client.chat_stream("Hi") { flunk "Unexpected callback" }
+      assert_equal 403, result["status"]
+      assert_equal "Denied", result["error"]
+    end
+    with_http(["Bad gateway"], "502") do
+      result = @client.chat_stream("Hi", debug: true) { flunk "Unexpected callback" }
+      assert_equal 502, result["status"]
+      assert_equal "Bad gateway", result["raw"]
+      refute_nil result["error"]
+    end
+    assert_raises(ArgumentError) { @client.chat_stream("Hi") }
+    with_http([start, delta("Hello")]) do
+      failure = RuntimeError.new("UI error")
+      assert_same failure, assert_raises(RuntimeError) { @client.chat_stream("Hi") { raise failure } }
+    end
+  end
+  def test_mixed_sse_newlines_and_lone_cr_at_eof
+    stream = start.gsub("\n\n", "\r\n\n") + delta("Hello") + finish.gsub("\n", "\r")
+    with_http(stream.bytes.map(&:chr)) do
+      parts = []
+      result = @client.chat_stream("Hi") { |text| parts << text }
+      assert_equal ["Hello"], parts
+      assert_equal "Hello", result["content"]
+      assert_nil result["error"]
+    end
+  end
+
+  def test_invalid_request_does_not_use_http
+    with_http([]) do |http, _|
+      refute_nil @client.chat_stream("Hi", options: { background: true }) { |_| }["error"]
+      refute_nil @client.chat_stream(nil) { |_| }["error"]
+      assert_nil http.request_received
+    end
+  end
+end