ai-lite 0.6.1 → 1.1.0

data/test/gemini_test.rb

@@ -0,0 +1,200 @@
+require_relative "test_helper"
+require "open3"
+require "rbconfig"
+
+class GeminiTest < 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 body(text = "Hello")
+    { "id" => "interaction_123", "status" => "completed", "steps" => [
+      { "type" => "thought", "content" => [{ "type" => "text", "text" => "Hidden" }] },
+      { "type" => "model_output", "content" => [{ "type" => "text", "text" => text }] }
+    ], "usage" => { "total_tokens" => 10 } }
+  end
+
+  def with_http(raw = body, 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_string_chat_transport_and_envelope
+    with_http do |http|
+      result = @client.chat("Tell me a joke")
+      assert_equal({ "content" => "Hello", "response_id" => "interaction_123", "status" => 200,
+                     "error" => nil, "raw" => nil }, result)
+      request = http.request_received
+      assert_equal "/v1beta/interactions", request.path
+      assert_equal "gemini-key", request["x-goog-api-key"]
+      assert_nil request["Authorization"]
+      assert_nil URI(request.path).query
+      payload = JSON.parse(request.body)
+      assert_equal "Tell me a joke", payload["input"]
+      assert_equal AiLite::Gemini::DEFAULT_MODEL, payload["model"]
+      assert_equal 2000, payload.dig("generation_config", "max_output_tokens")
+      assert_equal 9, http.open_timeout
+      assert_equal 9, http.read_timeout
+    end
+  end
+
+  def test_structured_inputs_and_history_pass_through_without_mutation
+    inputs = [
+      { type: "video", uri: "https://www.youtube.com/watch?v=example" },
+      [{ type: "video", uri: "https://www.youtube.com/watch?v=example" }, { type: "text", text: "Summarize" }],
+      [{ type: "user_input", content: [{ type: "text", text: "Hello" }] },
+       { type: "model_output", content: [{ type: "text", text: "Hi" }] }]
+    ]
+    inputs.each do |input|
+      original = Marshal.dump(input)
+      with_http do |http|
+        assert_nil @client.chat(input)["error"]
+        assert_equal JSON.parse(JSON.generate(input)), JSON.parse(http.request_received.body)["input"]
+        assert_equal original, Marshal.dump(input)
+      end
+    end
+  end
+
+  def test_keywords_and_provider_options
+    options = { "generation_config" => { "temperature" => 0.4, "max_output_tokens" => 50 },
+                "previous_interaction_id" => "old", store: false, response_format: { type: "object" } }
+    original = Marshal.dump(options)
+    with_http(body('{"ok":true}')) do |http|
+      result = @client.chat("Hello", model: "custom-model", instructions: "Be brief",
+                            previous_response_id: "previous", max_output_tokens: 25, debug: true, options: options)
+      payload = JSON.parse(http.request_received.body)
+      assert_equal "custom-model", payload["model"]
+      assert_equal "Be brief", payload["system_instruction"]
+      assert_equal "previous", payload["previous_interaction_id"]
+      refute payload.key?("previous_response_id")
+      assert_equal({ "temperature" => 0.4, "max_output_tokens" => 25 }, payload["generation_config"])
+      assert_equal false, payload["store"]
+      assert_equal({ "ok" => true }, result["content"])
+      assert_equal 10, result.dig("raw", "usage", "total_tokens")
+      assert_equal original, Marshal.dump(options)
+    end
+  end
+
+  def test_options_continuation_and_token_limit_without_keywords
+    with_http do |http|
+      @client.chat("Hi", options: { previous_interaction_id: "before", generation_config: { max_output_tokens: 33 } })
+      payload = JSON.parse(http.request_received.body)
+      assert_equal "before", payload["previous_interaction_id"]
+      assert_equal 33, payload.dig("generation_config", "max_output_tokens")
+    end
+  end
+
+  def test_config_and_cached_clients_are_isolated
+    AiLite::OpenAI.configure { |config| config.api_key = "openai-key"; config.model = "openai-model" }
+    openai = AiLite::OpenAI.client
+    AiLite::Gemini.configure do |config|
+      config.api_key = "configured-gemini"
+      config.model = "configured-model"
+      config.timeout = 14
+      config.max_output_tokens = 88
+    end
+    gemini = AiLite::Gemini.client
+    assert_same gemini, AiLite::Gemini.client
+    assert_equal "configured-gemini", gemini.api_key
+    assert_equal "configured-model", gemini.model
+    assert_equal 14, gemini.timeout
+    assert_equal 88, gemini.max_output_tokens
+    overridden = AiLite::Gemini.new(api_key: "explicit", model: "override", timeout: 3, max_output_tokens: 4)
+    assert_equal ["explicit", "override", 3, 4], [overridden.api_key, overridden.model, overridden.timeout, overridden.max_output_tokens]
+    AiLite::Gemini.configure { |config| config.api_key = "new-key" }
+    refute_same gemini, AiLite::Gemini.client
+    assert_same openai, AiLite::OpenAI.client
+    assert_equal "openai-key", openai.api_key
+    refute AiLite::Gemini < AiLite::OpenAI
+    %i[moderate transcribe speak].each { |method| refute_respond_to gemini, method }
+    with_http do
+      assert_equal "Hello", AiLite::Gemini.chat("Hello")["content"]
+    end
+  end
+
+  def test_gemini_key_fallback_does_not_use_openai_key
+    previous = ENV.to_h.slice("GEMINI_API_KEY", "OPENAI_API_KEY", "OPEN_AI_TOKEN")
+    ENV.delete("GEMINI_API_KEY")
+    ENV["OPENAI_API_KEY"] = "openai-only"
+    ENV["OPEN_AI_TOKEN"] = "legacy-only"
+    assert_raises(ArgumentError) { AiLite::Gemini.new }
+    ENV["GEMINI_API_KEY"] = "env-key"
+    assert_equal "env-key", AiLite::Gemini.new.api_key
+    AiLite::Gemini.configure { |config| config.api_key = "config-key" }
+    assert_equal "config-key", AiLite::Gemini.new.api_key
+    assert_equal "explicit-key", AiLite::Gemini.new(api_key: "explicit-key").api_key
+  ensure
+    %w[GEMINI_API_KEY OPENAI_API_KEY OPEN_AI_TOKEN].each do |key|
+      previous.key?(key) ? ENV[key] = previous[key] : ENV.delete(key)
+    end
+  end
+
+  def test_errors_and_noncompleted_interactions
+    with_http({ "error" => { "code" => 403, "message" => "Permission denied" } }, "403") do
+      result = @client.chat("Hi", debug: true)
+      assert_equal 403, result["status"]
+      assert_equal "Permission denied", result["error"]
+      refute_nil result["raw"]
+    end
+    ["bad json", [], {}, IOError.new("Disconnected")].each do |raw|
+      with_http(raw) { refute_nil @client.chat("Hi")["error"] }
+    end
+    %w[failed incomplete cancelled requires_action queued in_progress].each do |state|
+      with_http(body.merge("status" => state)) do
+        result = @client.chat("Hi", debug: true)
+        assert_includes result["error"], state
+        assert_equal "interaction_123", result["response_id"]
+      end
+    end
+    with_http(body.merge("status" => "failed", "error" => { "message" => "Generation failed" })) do
+      assert_equal "Generation failed", @client.chat("Hi")["error"]
+    end
+  end
+
+  def test_unsupported_execution_modes_and_invalid_inputs_do_not_call_http
+    with_http do |http|
+      [{ stream: true }, { "background" => true }, { generation_config: nil }].each do |options|
+        refute_nil @client.chat("Hi", options: options)["error"]
+      end
+      refute_nil @client.chat(nil)["error"]
+      assert_nil http.request_received
+    end
+  end
+
+  def test_direct_require
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-I#{File.expand_path('../lib', __dir__)}", "-e", <<~'CODE')
+      require "ai_lite/gemini"
+      abort unless AiLite::Gemini.new(api_key: "key").respond_to?(:chat)
+      abort if AiLite.const_defined?(:OpenAI, false)
+      require "ai_lite"
+      abort unless AiLite::OpenAI.new(api_key: "key").respond_to?(:chat)
+    CODE
+    assert status.success?, stderr
+    assert_empty stdout
+    assert_empty stderr
+  end
+end

data/test/gemini_youtube_test.rb

@@ -0,0 +1,57 @@
+require_relative "gemini_test"
+
+class GeminiYouTubeTest < GeminiTest
+  def test_youtube_builds_video_input_and_forwards_chat_options
+    url = "https://www.youtube.com/watch?v=DV69qh0BzoA"
+    with_http do |http|
+      result = @client.youtube(url, prompt: "Summarize this video", model: "custom",
+        instructions: "Be brief", previous_response_id: "previous", max_output_tokens: 100,
+        debug: true, options: { store: false })
+      payload = JSON.parse(http.request_received.body)
+      assert_equal [{ "type" => "video", "uri" => url }, { "type" => "text", "text" => "Summarize this video" }], payload["input"]
+      assert_equal "custom", payload["model"]
+      assert_equal "Be brief", payload["system_instruction"]
+      assert_equal "previous", payload["previous_interaction_id"]
+      assert_equal 100, payload.dig("generation_config", "max_output_tokens")
+      assert_equal false, payload["store"]
+      assert_equal "Hello", result["content"]
+      refute_nil result["raw"]
+    end
+  end
+
+  def test_supported_url_forms_and_class_method
+    AiLite::Gemini.configure { |c| c.api_key = "test-key" }
+    %w[https://youtu.be/DV69qh0BzoA?t=10 https://m.youtube.com/watch?v=DV69qh0BzoA https://youtube.com/shorts/DV69qh0BzoA https://www.youtube.com/embed/DV69qh0BzoA https://youtube.com/live/DV69qh0BzoA].each do |url|
+      with_http do
+        assert_nil AiLite::Gemini.youtube(url, prompt: "Summarize")["error"]
+      end
+    end
+  end
+
+  def test_rejects_invalid_urls_and_prompts_before_network
+    [nil, "garbage", "http://youtube.com/watch?v=DV69qh0BzoA", "https://youtube.com.evil.test/watch?v=DV69qh0BzoA",
+     "https://user@youtube.com/watch?v=DV69qh0BzoA", "https://youtube.com/watch?v=short",
+     "https://youtube.com/playlist?list=DV69qh0BzoA", "https://youtu.be/DV69qh0BzoA/extra",
+     "https://youtube.com/watch?v=DV69qh0BzoA&v=DV69qh0BzoA"].each do |url|
+      with_http do |http|
+        refute_nil @client.youtube(url, prompt: "Summarize")["error"]
+        assert_nil http.request_received
+      end
+    end
+    [nil, "", " "].each do |prompt|
+      with_http do |http|
+        refute_nil @client.youtube("https://youtu.be/DV69qh0BzoA", prompt: prompt)["error"]
+        assert_nil http.request_received
+      end
+    end
+  end
+
+  def test_provider_errors_are_preserved
+    with_http({ "error" => { "message" => "Video unavailable" } }, "400") do
+      result = @client.youtube("https://youtu.be/DV69qh0BzoA", prompt: "Summarize", debug: true)
+      assert_equal 400, result["status"]
+      assert_equal "Video unavailable", result["error"]
+      refute_nil result["raw"]
+    end
+  end
+end

data/test/openai_models_test.rb

@@ -0,0 +1,138 @@
+require_relative "test_helper"
+
+class OpenAIModelsTest < Minitest::Test
+  Response = Struct.new(:code, :body)
+  class Http
+    attr_accessor :open_timeout, :read_timeout
+    attr_reader :requests
+    def initialize(response)
+      @response, @requests = response, []
+    end
+    def request(request)
+      @requests << request
+      raise @response if @response.is_a?(Exception)
+      @response
+    end
+  end
+
+  def setup
+    AiLite::OpenAI.reset_configuration!
+    @client = AiLite::OpenAI.new(api_key: "test-key", model: "chat-test", timeout: 7)
+  end
+
+  def with_http(body, status = "200")
+    response = body.is_a?(Exception) ? body : Response.new(status, body.is_a?(String) ? body : JSON.generate(body))
+    http = Http.new(response)
+    original = Net::HTTP.method(:start)
+    Net::HTTP.define_singleton_method(:start) do |host, port, use_ssl:, &block|
+      raise "Unexpected host" unless host == "api.openai.com" && port == 443 && use_ssl
+      block.call(http)
+    end
+    yield http
+  ensure
+    Net::HTTP.define_singleton_method(:start, original)
+  end
+
+  def test_get_model_ids_and_debug_metadata
+    body = { "data" => [{ "id" => "chat-test", "owned_by" => "openai" }, { "id" => "other" }] }
+    with_http(body) do |http|
+      result = @client.available_models(debug: true)
+      assert_equal ["chat-test", "other"], result["content"]
+      assert_equal body, result["raw"]
+      assert_equal 200, result["status"]
+      assert_nil result["error"]
+      assert_nil result["response_id"]
+      request = http.requests.fetch(0)
+      assert_instance_of Net::HTTP::Get, request
+      assert_equal "/v1/models", request.path
+      assert_equal "Bearer test-key", request["Authorization"]
+      assert_nil request.body
+      assert_equal 7, http.open_timeout
+      assert_equal 7, http.read_timeout
+      assert_nil @client.available_models["raw"]
+    end
+  end
+
+  def test_exact_predicate_and_empty_list
+    with_http("data" => [{ "id" => "chat-test" }]) do
+      assert_equal true, @client.model_available?("chat-test")
+      assert_equal false, @client.model_available?("chat")
+      assert_equal false, @client.model_available?("CHAT-TEST")
+    end
+    with_http("data" => []) do
+      assert_equal [], @client.available_models["content"]
+      assert_equal false, @client.model_available?("chat-test")
+    end
+    [nil, "", " ", :model].each do |input|
+      assert_raises(ArgumentError) { @client.model_available?(input) }
+    end
+  end
+
+  def test_local_configuration_never_uses_network_or_needs_key
+    with_http(RuntimeError.new("Must not call network")) do |http|
+      AiLite::OpenAI.configure { |config| config.model = "global-model" }
+      assert_equal "global-model", AiLite::OpenAI.configured_models["chat"]
+      snapshot = @client.configured_models
+      assert_equal "chat-test", snapshot["chat"]
+      assert_equal %w[chat moderation embedding image speech transcription], snapshot.keys
+      snapshot["chat"].replace("changed")
+      assert_equal "chat-test", @client.model
+      assert_empty http.requests
+    end
+  end
+
+  def test_check_uses_one_get_for_all_usages_including_duplicate_models
+    client = AiLite::OpenAI.new(api_key: "test-key", model: "same", embedding_model: "same")
+    with_http("data" => [{ "id" => "same" }]) do |http|
+      result = client.check_configured_models(debug: true)
+      assert_equal 1, http.requests.length
+      assert_equal 6, result["content"].length
+      assert_equal true, result.dig("content", "chat", "available")
+      assert_equal true, result.dig("content", "embedding", "available")
+      assert_equal false, result.dig("content", "image", "available")
+      assert_equal "chat", result.dig("content", "chat", "usage")
+      assert_nil result["error"]
+      refute_nil result["raw"]
+    end
+  end
+
+  def test_http_parse_shape_and_network_errors_are_not_missing_models
+    cases = [
+      [{ "error" => { "message" => "Unauthorized" } }, "401"],
+      [{ "error" => { "message" => "Rate limited" } }, "429"],
+      ["Bad gateway", "502"], ["not json", "200"], [[], "200"],
+      [{ "data" => [{}] }, "200"], [{}, "200"],
+      [IOError.new("Connection lost"), "200"]
+    ]
+    cases.each do |body, status|
+      with_http(body, status) do |http|
+        result = @client.available_models(debug: true)
+        refute_nil result["error"]
+        assert_nil result["content"]
+        assert_nil @client.model_available?("chat-test")
+        before = http.requests.length
+        report = @client.check_configured_models
+        assert_equal before + 1, http.requests.length
+        refute_nil report["error"]
+        report["content"].each_value do |entry|
+          assert_nil entry["available"]
+          assert_equal report["error"], entry["error"]
+        end
+      end
+    end
+  end
+
+  def test_class_and_legacy_delegation
+    AiLite::OpenAI.configure { |config| config.api_key = "test-key"; config.model = "chat-test" }
+    [AiLite::OpenAI, AiLite].each do |provider|
+      with_http("data" => [{ "id" => "chat-test" }]) do
+        capture_io do
+          assert_equal ["chat-test"], provider.available_models["content"]
+          assert_equal true, provider.model_available?("chat-test")
+          assert_equal "chat-test", provider.configured_models["chat"]
+          assert_equal true, provider.check_configured_models.dig("content", "chat", "available")
+        end
+      end
+    end
+  end
+end

data/test/openai_streaming_test.rb

@@ -0,0 +1,189 @@
+require_relative "test_helper"
+
+class OpenAIStreamingTest < Minitest::Test
+  class Response
+    attr_reader :code, :read_count
+    def initialize(chunks, code = "200")
+      @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::OpenAI.reset_configuration!
+    @client = AiLite::OpenAI.new(api_key: "test-key", timeout: 17)
+  end
+
+  def event(type, fields = {})
+    "event: #{type}\ndata: #{JSON.generate(fields.merge('type' => type))}\n\n"
+  end
+
+  def completed(text = "Hello")
+    event("response.completed", "response" => {
+      "id" => "resp_test", "status" => "completed", "usage" => { "output_tokens" => 2 },
+      "output" => [{ "type" => "message", "content" => [{ "type" => "output_text", "text" => text }] }]
+    })
+  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 endpoint" unless host == "api.openai.com" && port == 443 && use_ssl
+      block.call(http)
+    end
+    yield http, response
+  ensure
+    Net::HTTP.define_singleton_method(:start, original)
+  end
+
+  def test_yields_before_reading_next_chunk_and_preserves_chat_options
+    chunks = [event("response.output_text.delta", "delta" => "Hel"),
+              event("response.output_text.delta", "delta" => "lo"), completed]
+    with_http(chunks) do |http, response|
+      yielded = []
+      result = @client.chat_stream([{ role: "user", content: "Hi" }], model: "test-model",
+        instructions: "Be brief", previous_response_id: "resp_before", max_output_tokens: 9,
+        options: { "stream" => false, stream: false, temperature: 0.5 }, debug: true) do |delta|
+        yielded << delta
+        assert_equal yielded.length, response.read_count
+      end
+      assert_equal ["Hel", "lo"], yielded
+      assert_equal "Hello", result["content"]
+      assert_equal "resp_test", result["response_id"]
+      assert_equal 200, result["status"]
+      assert_nil result["error"]
+      assert_equal 2, result.dig("raw", "usage", "output_tokens")
+      request = http.request_received
+      payload = JSON.parse(request.body)
+      assert_equal "/v1/responses", request.path
+      assert_equal "Bearer test-key", request["Authorization"]
+      assert_equal "text/event-stream", request["Accept"]
+      assert_equal true, payload["stream"]
+      assert_equal "test-model", payload["model"]
+      assert_equal "Be brief", payload["instructions"]
+      assert_equal "resp_before", payload["previous_response_id"]
+      assert_equal 9, payload["max_output_tokens"]
+      assert_equal 0.5, payload["temperature"]
+      assert_equal [{ "role" => "user", "content" => "Hi" }], payload["input"]
+      assert_equal 17, http.open_timeout
+      assert_equal 17, http.read_timeout
+    end
+  end
+
+  def test_byte_splits_crlf_comments_multiline_data_and_ignored_events
+    stream = ": heartbeat\r\n\r\n" +
+      "data: {\"type\":\"response.output_text.delta\",\r\ndata: \"delta\":\"Hi 🌍\"}\r\n\r\n" +
+      event("response.output_text.done", "text" => "Hi 🌍") + completed("Hi 🌍")
+    with_http(stream.bytes.map { |byte| byte.chr }) do
+      parts = []
+      result = @client.chat_stream("Hi") { |delta| parts << delta }
+      assert_equal ["Hi 🌍"], parts
+      assert_equal "Hi 🌍", result["content"]
+      assert_nil result["raw"]
+      assert_nil result["error"]
+    end
+  end
+
+  def test_json_final_content_and_multiple_events_in_one_chunk
+    with_http([event("response.output_text.delta", "delta" => '{"ok":true}') + completed('{"ok":true}')]) do
+      parts = []
+      result = @client.chat_stream("Hi") { |delta| parts << delta }
+      assert_equal ['{"ok":true}'], parts
+      assert_equal({ "ok" => true }, result["content"])
+    end
+  end
+
+  def test_failed_incomplete_and_error_events_preserve_partial_text
+    terminals = [
+      [event("response.failed", "response" => { "id" => "resp_test", "error" => { "message" => "Failed" } }), "Failed"],
+      [event("response.incomplete", "response" => { "id" => "resp_test", "incomplete_details" => { "reason" => "max_output_tokens" } }), "Response incomplete: max_output_tokens"],
+      [event("error", "message" => "Rate limited"), "Rate limited"]
+    ]
+    terminals.each do |terminal, message|
+      with_http([event("response.created", "response" => { "id" => "resp_test" }),
+                 event("response.output_text.delta", "delta" => "Partial"), terminal]) do
+        result = @client.chat_stream("Hi", debug: true) { |_| }
+        assert_equal "Partial", result["content"]
+        assert_equal message, result["error"]
+        assert_equal "resp_test", result["response_id"]
+        refute_nil result["raw"]
+      end
+    end
+  end
+
+  def test_truncation_done_marker_malformed_json_and_disconnect_are_errors
+    [[], ["data: [DONE]\n\n"], ["data: {bad}\n\n"], ["data: {"], [IOError.new("Connection lost")]].each do |tail|
+      with_http([event("response.output_text.delta", "delta" => "Partial")] + tail) do
+        result = @client.chat_stream("Hi") { |_| }
+        assert_equal "Partial", result["content"]
+        refute_nil result["error"]
+      end
+    end
+  end
+
+  def test_http_errors_do_not_yield
+    ['{"error":{"message":"Invalid API key"}}', "Bad gateway"].each do |body|
+      with_http([body], "401") do
+        result = @client.chat_stream("Hi", debug: true) { flunk "Should not yield" }
+        assert_equal 401, result["status"]
+        refute_nil result["error"]
+        refute_nil result["raw"]
+      end
+    end
+  end
+
+  def test_missing_block_and_callback_errors_raise
+    assert_raises(ArgumentError) { @client.chat_stream("Hi") }
+    with_http([event("response.output_text.delta", "delta" => "Hello")]) do
+      error = RuntimeError.new("UI failed")
+      raised = assert_raises(RuntimeError) { @client.chat_stream("Hi") { raise error } }
+      assert_same error, raised
+    end
+  end
+
+  def test_mixed_sse_newlines_and_lone_cr_at_eof
+    stream = "data: {\"type\":\"response.output_text.delta\",\"delta\":\"Hello\"}\r\n\n" + completed.gsub("\n", "\r")
+    with_http(stream.bytes.map(&:chr)) do
+      parts = []
+      result = @client.chat_stream("Hi") { |delta| parts << delta }
+      assert_equal ["Hello"], parts
+      assert_equal "Hello", result["content"]
+      assert_nil result["error"]
+    end
+  end
+
+  def test_provider_and_legacy_class_methods_forward_blocks
+    AiLite::OpenAI.configure { |config| config.api_key = "test-key" }
+    [AiLite::OpenAI, AiLite].each do |provider|
+      with_http([event("response.output_text.delta", "delta" => "Hello"), completed]) do
+        parts = []
+        capture_io do
+          result = provider.chat_stream("Hi") { |delta| parts << delta }
+          assert_equal "Hello", result["content"]
+        end
+        assert_equal ["Hello"], parts
+      end
+    end
+  end
+end

data/test/run.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, "*_test.rb")].sort.each { |file| require file }

metadata

@@ -1,33 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: ai-lite
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 1.1.0
 platform: ruby
 authors:
 - William Basmayor
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies: []
 description: AI Lite is a dependency-light Ruby client for Rails apps and plain Ruby
-  projects that need simple OpenAI chat, moderation, embedding, image, speech, and
-  transcription calls.
+  projects, using only the Ruby standard library. It provides OpenAI chat, streaming,
+  moderation, embeddings, images, speech, transcription, and model checks, plus Gemini
+  chat, streaming, embeddings, image generation, structured media inputs, and model
+  checks.
 email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/ai_lite.rb
+- lib/ai_lite/gemini.rb
+- lib/ai_lite/gemini/chat.rb
+- lib/ai_lite/gemini/configuration.rb
+- lib/ai_lite/gemini/embeddings.rb
+- lib/ai_lite/gemini/images.rb
+- lib/ai_lite/gemini/models.rb
+- lib/ai_lite/gemini/streaming.rb
+- lib/ai_lite/gemini/youtube.rb
+- lib/ai_lite/openai.rb
+- lib/ai_lite/openai/configuration.rb
+- lib/ai_lite/openai/models.rb
+- lib/ai_lite/openai/streaming.rb
 - lib/ai_lite/version.rb
 - test/ai_lite_test.rb
+- test/gemini_embeddings_test.rb
+- test/gemini_images_test.rb
+- test/gemini_models_test.rb
+- test/gemini_streaming_test.rb
+- test/gemini_test.rb
+- test/gemini_youtube_test.rb
+- test/openai_models_test.rb
+- test/openai_streaming_test.rb
+- test/run.rb
 - test/test_helper.rb
 homepage: https://github.com/wbasmayor/ai-lite
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/wbasmayor/ai-lite
+  changelog_uri: https://github.com/wbasmayor/ai-lite/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -46,5 +72,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Minimal Ruby client for simple OpenAI API calls.
+summary: Lightweight Ruby client with separate OpenAI and Gemini providers.
 test_files: []