ai-lite 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d320744aa3ea523ee76415327cad74343186881e21e28910b6b13a556d46eef3
-  data.tar.gz: e93d793fdeeefb1c8a2498906b48826934eee3981cadeb4f7073005e0140bd41
+  metadata.gz: a6b2ed589de27af46e6ce7babfb4a1ec32808ecfae567f29ed8db35bfd129f26
+  data.tar.gz: ddee8996d702a77709b30bd9bb360994abfbc3e4875386db04b99241541a413d
 SHA512:
-  metadata.gz: 4fa921ce3f81bdaed04e0facab46c8efdb863b98299d9452ba9f6bdac90d3a9f302e5850e067529b7d66f9552ff41945bb75f38257d6515ba761673c0d8f71d5
-  data.tar.gz: 0575ce9fb53e2f419940c08a6626a4d528a5661d7cef2e5cbca7c3b9b22587c0288ea4db37b69d6bf03fd8d470c66de68df6515fb226ceb77483b2beb91a90ab
+  metadata.gz: 9591556daadccbb5107f8b52f6d5ca825232003336a87db144e41971ec9921282a38ea884928d0d1f5ee8ea4d84fb8b67698ddcfb1894f678ab2bc615a9dcdb8
+  data.tar.gz: 24aa31e8ddaa48bf6876bc7e4375c212d46994d37709a32bb52c797b3618f0dc770fe831919039781c2f9529b40ff0c85b12c04dea4a7894c61fa4e8515fa282

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+- Add Gemini image generation with base64 results, optional file output, native
+  options, image model configuration, and model checks.
+
+- Add Gemini text embeddings for single and multiple inputs, with dimensions,
+  embedding model configuration, model checks, and the standard result envelope.
+
 ## 1.0.0 (unreleased)
 
 - Introduce independent `AiLite::OpenAI` and `AiLite::Gemini` providers.
@@ -14,5 +22,5 @@
 - Treat failed/incomplete OpenAI generations as errors even when HTTP status is 200.
 - Handle fragmented UTF-8 and mixed SSE line endings in both stream parsers.
 
-Gemini embeddings, image generation, speech, file transcription, additional
+Gemini image generation, speech, file transcription, additional
 providers, and async convenience methods are deferred beyond v1.

data/README.md

@@ -1,30 +1,42 @@
 # AI Lite
 
-AI Lite is a pure Ruby, dependency-light client with separate OpenAI and Gemini providers.
-OpenAI supports the full utility methods below; Gemini supports chat and streaming with text and structured media input.
+AI Lite is a lightweight, pure Ruby client for OpenAI and Gemini. Both providers
+support chat, streaming, embeddings, image generation, and model availability
+checks through simple interfaces and a consistent result format.
 
-It is built for Rails apps and plain Ruby projects where installing a full OpenAI SDK is too heavy, incompatible, or unnecessary. It is especially useful in legacy Rails apps where Rails, ActiveSupport, Ruby, or HTTP-client dependency constraints make larger client libraries difficult to add.
-
-Use AI Lite when you want a small OpenAI client that works without tying your app to a specific Rails version or a larger dependency stack.
+It is built for Rails apps and plain Ruby projects that need AI features with
+minimal dependencies. It is especially useful in legacy Rails apps where Ruby,
+Rails, or HTTP-client dependency constraints make larger SDKs difficult to add.
 
 This gem is intentionally small:
 
 - No Rails dependency
-- No official OpenAI gem dependency
+- No provider SDK dependency
 - No Faraday, HTTParty, ActiveSupport, or connection pool dependency
 - Uses only Ruby stdlib: `Net::HTTP`, `URI`, `JSON`, `Base64`, and `SecureRandom`
 
-It is not meant to replace the official OpenAI SDK. It is a small wrapper for projects that only need a few clean interfaces:
+Choose a provider and call the methods your app needs:
 
 ```ruby
-ai.chat("Say hello")
-ai.moderate("User submitted text")
-ai.embed("Text to vectorize")
-ai.image("A simple app icon")
-ai.speak("Read this aloud")
-ai.transcribe("tmp/meeting.mp3")
+require "ai_lite"
+
+openai = AiLite::OpenAI.new # Reads OPENAI_API_KEY
+gemini = AiLite::Gemini.new # Reads GEMINI_API_KEY
+
+openai.chat("Say hello")
+gemini.chat("Say hello")
+
+openai.embed("Text to vectorize")
+gemini.embed("Text to vectorize")
+
+openai.image("A simple app icon")
+gemini.image("A simple app icon")
 ```
 
+Each provider has independent configuration and native API options. OpenAI also
+supports moderation, speech, and file transcription; Gemini supports structured
+media input and a YouTube helper. The table below lists the available methods.
+
 ## Provider support
 
 | Method | OpenAI | Gemini |
@@ -32,7 +44,8 @@ ai.transcribe("tmp/meeting.mp3")
 | `chat`, `chat_stream` | Yes | Yes |
 | Four model helpers | Yes | Yes |
 | `youtube` | No | Yes |
-| `moderate`, `embed`, `image`, `speak`, `transcribe` | Yes | Not implemented |
+| `embed`, `image` | Yes | Yes |
+| `moderate`, `speak`, `transcribe` | Yes | Not implemented |
 
 Unsupported provider methods are absent and raise Ruby's `NoMethodError` if called.
 Configure providers during application startup; do not mutate shared configuration
@@ -58,6 +71,8 @@ does not load `.env` automatically.
 AiLite::Gemini.configure do |config|
   config.api_key = ENV["GEMINI_API_KEY"]
   config.model = "gemini-3.8-flash"
+  config.embedding_model = "gemini-embedding-001"
+  config.image_model = "gemini-nano-banana-2.1"
   config.timeout = 120
   config.max_output_tokens = 2000
 end
@@ -117,10 +132,72 @@ return an error rather than pretending the answer is complete; no tools are
 executed automatically. Input/API/transport errors return an error envelope;
 constructing a client without a key raises `ArgumentError`.
 
-Gemini embeddings and image/speech methods are not implemented yet. Use `chat_stream` for streaming; `chat` rejects
+Gemini speech and file transcription methods are not implemented yet. Use `chat_stream` for streaming; `chat` rejects
 `stream: true`. Both methods reject `background: true` before sending a request.
 Legacy `AiLite` entry points still use OpenAI.
 
+### Gemini embeddings
+
+`embed` mirrors OpenAI's text input and return shape: a string returns one numeric
+vector in `content`; an array returns a list of vectors in input order, including
+an array containing just one string.
+
+```ruby
+gemini = AiLite::Gemini.new
+result = gemini.embed("Text to vectorize")
+result["content"] # [0.12, -0.34, ...]
+
+gemini.embed(["First text", "Second text"], dimensions: 768)
+AiLite::Gemini.embed("Search query", options: { taskType: "RETRIEVAL_QUERY" })
+```
+
+The default is `gemini-embedding-001`. Override it with `embedding_model:` in the
+constructor, `config.embedding_model`, or `model:` per call. Both bare model IDs
+and `models/` prefixes are accepted. Model checks include the embedding model.
+
+Single strings use `embedContent`; arrays use one synchronous `batchEmbedContents`
+request. `dimensions:` maps to `outputDimensionality`. Native request fields in
+`options:` apply to each input; explicit model, input, and dimensions take precedence.
+See Google's [embedding API reference](https://ai.google.dev/api/embeddings).
+
+Gemini returns numeric vectors; `encoding_format:` may be omitted or set to
+`"float"`. Other formats return an error envelope. Empty inputs and invalid dimensions
+also return errors before making a request. `debug: true` retains the provider
+response and any usage metadata in `raw`; `response_id` is `nil` for embeddings.
+
+### Gemini image generation
+
+```ruby
+gemini = AiLite::Gemini.new
+result = gemini.image("A cat astronaut on the moon", output_path: "tmp/cat.jpg")
+result["content"] # Base64 image data, also returned when saving to a file
+
+AiLite::Gemini.image("A mountain landscape", options: {
+  response_format: { type: "image", aspect_ratio: "16:9", image_size: "2K" }
+})
+```
+
+The default image model is `gemini-nano-banana-2.1`. Set `config.image_model`,
+pass `image_model:` to the constructor, or override `model:` per call.
+Model checks include this setting. Requests use the Interactions API, with native
+settings passed through `options:`. Explicit prompt and model take precedence.
+Image requests do not inherit the chat output-token limit.
+
+Like OpenAI's `image`, `content` contains the first generated image as base64.
+Only image blocks from `model_output` steps are selected. `output_path:` saves
+its decoded bytes; the parent directory must already exist. Files retain the
+provider's encoding: the filename does not convert the image. Use `debug: true`
+to inspect MIME type, additional images, text, and usage in `raw`. Gemini can return
+JPEG data even when the output filename ends in `.png`; choose the extension to
+match the returned image MIME type. AI Lite does not transcode images.
+
+The initial interface accepts a text prompt, `model:`, `output_path:`, `debug:`,
+and `options:`. OpenAI-specific size, quality, background, and output format
+keywords are not shared; use Gemini's native `response_format` options as above.
+Streaming and background execution are rejected. Failed/incomplete interactions,
+missing or invalid image data, and file-write errors return error envelopes.
+See Google's [image generation guide](https://ai.google.dev/gemini-api/docs/image-generation).
+
 ### Gemini model checks
 
 ```ruby
@@ -129,7 +206,7 @@ result = gemini.available_models
 puts result["content"] unless result["error"]
 
 gemini.model_available?("gemini-3.8-flash") # true / false / nil on lookup failure
-gemini.configured_models                  # { "chat" => "gemini-3.8-flash" }
+gemini.configured_models                  # Includes chat, embedding, and image models
 gemini.check_configured_models            # Standard envelope containing a report
 
 # All four also work at class level:

data/lib/ai_lite/gemini/configuration.rb

@@ -2,15 +2,19 @@ class AiLite
   class Gemini
     API_BASE_URL = "https://generativelanguage.googleapis.com/v1beta".freeze
     DEFAULT_MODEL = "gemini-3.8-flash".freeze
+    DEFAULT_EMBEDDING_MODEL = "gemini-embedding-001".freeze
+    DEFAULT_IMAGE_MODEL = "gemini-nano-banana-2.1".freeze
     DEFAULT_TIMEOUT = 120
     DEFAULT_MAX_OUTPUT_TOKENS = 2000
 
     class Configuration
-      attr_accessor :api_key, :model, :timeout, :max_output_tokens
+      attr_accessor :api_key, :model, :embedding_model, :image_model, :timeout, :max_output_tokens
 
       def initialize
         @api_key = nil
         @model = DEFAULT_MODEL
+        @embedding_model = DEFAULT_EMBEDDING_MODEL
+        @image_model = DEFAULT_IMAGE_MODEL
         @timeout = DEFAULT_TIMEOUT
         @max_output_tokens = DEFAULT_MAX_OUTPUT_TOKENS
       end

data/lib/ai_lite/gemini/embeddings.rb

@@ -0,0 +1,58 @@
+class AiLite
+  class Gemini
+    module Embeddings
+      def embed(input, model: nil, dimensions: nil, encoding_format: nil, debug: false, options: {})
+        response = nil
+        raw = nil
+        multiple = input.is_a?(Array)
+        texts = multiple ? input : [input]
+        unless !texts.empty? && texts.all? { |text| text.is_a?(String) && !text.strip.empty? }
+          raise ArgumentError, "input must be a nonempty string or array of nonempty strings"
+        end
+        unless dimensions.nil? || (dimensions.is_a?(Integer) && dimensions > 0)
+          raise ArgumentError, "dimensions must be a positive integer"
+        end
+        unless encoding_format.nil? || encoding_format == "float"
+          raise ArgumentError, "Gemini embeddings only support encoding_format: float"
+        end
+        model_id = model || embedding_model
+        unless model_id.is_a?(String) && model_id.match?(%r{\A(?:models/)?[A-Za-z0-9._-]+\z})
+          raise ArgumentError, "model must be a Gemini model ID"
+        end
+        resource = "models/#{model_id.delete_prefix('models/')}"
+        settings = options.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
+        settings["outputDimensionality"] = dimensions if dimensions
+        requests = texts.map do |text|
+          settings.merge("model" => resource, "content" => { "parts" => [{ "text" => text }] })
+        end
+        action = multiple ? "batchEmbedContents" : "embedContent"
+        payload = multiple ? { "requests" => requests } : requests.first
+        response = post_json(payload, endpoint: "#{API_BASE_URL}/#{resource}:#{action}")
+        raw = response.body
+        raw = JSON.parse(raw)
+        raise "Invalid Gemini embedding response: expected an object" unless raw.is_a?(Hash)
+        if !response.code.to_i.between?(200, 299) || raw["error"]
+          return result_envelope(status: response.code.to_i, error: error_message(raw), raw: raw, debug: debug)
+        end
+        embeddings = multiple ? raw["embeddings"] : [raw["embedding"]]
+        unless embeddings.is_a?(Array) && embeddings.length == texts.length
+          raise "Invalid Gemini embedding response: unexpected embedding count"
+        end
+        vectors = embeddings.map do |entry|
+          values = entry["values"] if entry.is_a?(Hash)
+          unless values.is_a?(Array) && !values.empty? && values.all? { |value| value.is_a?(Numeric) }
+            raise "Invalid Gemini embedding response: expected numeric values"
+          end
+          values
+        end
+        result_envelope(status: response.code.to_i, content: multiple ? vectors : vectors.first,
+                        raw: raw, debug: debug)
+      rescue StandardError => e
+        result_envelope(status: response ? response.code.to_i : "unknown", error: e.message, raw: raw, debug: debug)
+      end
+    end
+
+    include Embeddings
+    private_constant :Embeddings
+  end
+end

data/lib/ai_lite/gemini/images.rb

@@ -0,0 +1,56 @@
+class AiLite
+  class Gemini
+    module Images
+      def image(prompt, model: nil, output_path: nil, debug: false, options: {})
+        response = nil
+        raw = nil
+        response_id = nil
+        unless prompt.is_a?(String) && !prompt.strip.empty?
+          raise ArgumentError, "prompt must be a nonempty string"
+        end
+        payload = options.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
+        if payload["stream"] || payload["background"]
+          raise ArgumentError, "image does not support streaming or background execution"
+        end
+        payload.merge!("model" => model || image_model, "input" => prompt)
+        response = post_interaction(payload)
+        raw = response.body
+        raw = JSON.parse(raw)
+        raise "Invalid Gemini image response: expected an object" unless raw.is_a?(Hash)
+
+        response_id = raw["id"]
+        if !response.code.to_i.between?(200, 299) || raw["error"]
+          return result_envelope(status: response.code.to_i, error: error_message(raw),
+                                 response_id: response_id, raw: raw, debug: debug)
+        end
+        unless raw["status"] == "completed"
+          raise "Gemini interaction #{raw['status'] || 'has no status'}; inspect raw with debug: true"
+        end
+        steps = raw["steps"]
+        raise "Invalid Gemini image response: expected steps" unless steps.is_a?(Array)
+
+        image = steps.flat_map do |step|
+          next [] unless step.is_a?(Hash) && step["type"] == "model_output"
+
+          step["content"].is_a?(Array) ? step["content"] : []
+        end.find { |part| part.is_a?(Hash) && part["type"] == "image" }
+        content = image && image["data"]
+        unless content.is_a?(String) && !content.empty?
+          raise "No inline image data returned; inspect raw with debug: true"
+        end
+        bytes = Base64.strict_decode64(content)
+        raise "Empty image data returned" if bytes.empty?
+
+        File.binwrite(output_path, bytes) if output_path
+        result_envelope(status: response.code.to_i, content: content, response_id: response_id,
+                        raw: raw, debug: debug)
+      rescue StandardError => e
+        result_envelope(status: response ? response.code.to_i : "unknown", error: e.message,
+                        response_id: response_id, raw: raw, debug: debug)
+      end
+    end
+
+    include Images
+    private_constant :Images
+  end
+end

data/lib/ai_lite/gemini/models.rb

@@ -2,7 +2,9 @@ class AiLite
   class Gemini
     module Models
       def self.snapshot(source)
-        { "chat" => source.model.is_a?(String) ? source.model.dup : source.model }
+        { "chat" => source.model, "embedding" => source.embedding_model, "image" => source.image_model }.transform_values do |model|
+          model.is_a?(String) ? model.dup : model
+        end
       end
 
       def configured_models

data/lib/ai_lite/gemini.rb

@@ -1,9 +1,12 @@
 require "json"
 require "net/http"
 require "uri"
+require "base64"
 require_relative "version"
 require_relative "gemini/configuration"
 require_relative "gemini/chat"
+require_relative "gemini/embeddings"
+require_relative "gemini/images"
 require_relative "gemini/streaming"
 require_relative "gemini/youtube"
 require_relative "gemini/models"
@@ -43,19 +46,29 @@ class AiLite
         client.chat_stream(message, **kwargs, &block)
       end
 
+      def image(prompt, **kwargs)
+        client.image(prompt, **kwargs)
+      end
+
+      def embed(input, **kwargs)
+        client.embed(input, **kwargs)
+      end
+
       def chat(message, **kwargs)
         client.chat(message, **kwargs)
       end
     end
 
-    attr_reader :api_key, :model, :timeout, :max_output_tokens, :headers
+    attr_reader :api_key, :model, :embedding_model, :image_model, :timeout, :max_output_tokens, :headers
 
-    def initialize(api_key: nil, model: nil, timeout: nil, max_output_tokens: nil)
+    def initialize(api_key: nil, model: nil, embedding_model: nil, image_model: nil, timeout: nil, max_output_tokens: nil)
       config = self.class.configuration
       @api_key = api_key || config.api_key || ENV["GEMINI_API_KEY"]
       raise ArgumentError, "Missing Gemini API key" if @api_key.to_s.strip.empty?
 
       @model = model || config.model
+      @embedding_model = embedding_model || config.embedding_model
+      @image_model = image_model || config.image_model
       @timeout = timeout || config.timeout
       @max_output_tokens = max_output_tokens || config.max_output_tokens
       @headers = { "x-goog-api-key" => @api_key, "Content-Type" => "application/json" }
@@ -64,7 +77,11 @@ class AiLite
     private
 
     def post_interaction(payload)
-      uri = URI.parse("#{API_BASE_URL}/interactions")
+      post_json(payload, endpoint: "#{API_BASE_URL}/interactions")
+    end
+
+    def post_json(payload, endpoint:)
+      uri = URI.parse(endpoint)
       request = Net::HTTP::Post.new(uri)
       headers.each { |key, value| request[key] = value }
       request.body = JSON.generate(payload)

data/lib/ai_lite/version.rb

@@ -1,3 +1,3 @@
 class AiLite
-  VERSION = "1.0.0".freeze
+  VERSION = "1.1.0".freeze
 end

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

@@ -65,7 +65,7 @@ class GeminiModelsTest < Minitest::Test
   end
   def test_local_configuration_and_single_paginated_check
     with_pages do |http|
-      assert_equal({ "chat" => AiLite::Gemini::DEFAULT_MODEL }, AiLite::Gemini.configured_models)
+      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
@@ -74,7 +74,8 @@ class GeminiModelsTest < Minitest::Test
     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_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

data/test/gemini_test.rb

@@ -130,7 +130,7 @@ class GeminiTest < Minitest::Test
     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 }
+    %i[moderate transcribe speak].each { |method| refute_respond_to gemini, method }
     with_http do
       assert_equal "Hello", AiLite::Gemini.chat("Hello")["content"]
     end

metadata

@@ -1,19 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: ai-lite
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - William Basmayor
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-10 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, using only the Ruby standard library. It provides OpenAI chat, streaming,
   moderation, embeddings, images, speech, transcription, and model checks, plus Gemini
-  chat, streaming, structured media inputs, and model checks.
+  chat, streaming, embeddings, image generation, structured media inputs, and model
+  checks.
 email:
 executables: []
 extensions: []
@@ -26,6 +27,8 @@ files:
 - 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
@@ -35,6 +38,8 @@ files:
 - 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