ai-lite 0.6.1 → 1.0.0

data/test/gemini_models_test.rb

@@ -0,0 +1,112 @@
+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 }, 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"])
+      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

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 image speak embed].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