ai-lite 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fbb65bf2c01cdc7950a76cc5a273c0b495174bb9d671f7b5d32d49a79274b34
-  data.tar.gz: e8e909ff9c107f552e1f6a81772b3800bb2b1904bf9a5da50cfe6a2ca2380bd4
+  metadata.gz: 4f75f42caf4d74f3abf2ec982b7c3830c715b1d1c54f2ae0fdf02a1dec5151db
+  data.tar.gz: ff953a4533862067eee149c04ac5f348bf3b97e7e9f7b87fbcd18a3fe3d63233
 SHA512:
-  metadata.gz: ef2a0f01ea606b121b583134f6026c7d23388b3a58732a5a1f197275cb7178d2547ffea5040956955fd39452f944f1703833a4ba4925d0d2314ef2693372b904
-  data.tar.gz: 272108490b47700c06f49fb817d684fa6a2dbd003e02eff35fa59f19db8fe120e41983d941c32a50c640ef6776aee00038bc5ed841bef60cdde04fee854ea0c4
+  metadata.gz: c2c91c198575156c15e0100c3fa12709b1cf09395785d4a634e46bf06e9bc9dbf9e8073a95e990f54c4e19a0b72322379317299443899d83eef5c587864b6781
+  data.tar.gz: c528951faf3fe8f453def5a8dbaf7eb00c7da77fc5135c22ccfe2ac5765a2603a0c5cf50dcdfcbe1dda7aaedf6f69ca210a19424b67ef2866c627cd40e17104e

data/README.md

@@ -18,6 +18,8 @@ It is not meant to replace the official OpenAI SDK. It is a small wrapper for pr
 ```ruby
 ai.chat("Say hello")
 ai.moderate("User submitted text")
+ai.embed("Text to vectorize")
+ai.image("A simple app icon")
 ```
 
 ## Usage
@@ -49,6 +51,8 @@ AiLite.configure do |config|
   config.api_key = ENV["OPENAI_API_KEY"]
   config.model = "gpt-5.5"
   config.moderation_model = "omni-moderation-latest"
+  config.embedding_model = "text-embedding-3-small"
+  config.image_model = "gpt-image-2"
   config.timeout = 120
   config.max_output_tokens = 2000
 end
@@ -95,16 +99,43 @@ The OpenAI API URL is fixed to `https://api.openai.com/v1/responses`.
 
 ## Moderation
 
-Use `moderate` to classify text or images for potentially harmful content:
+Use `moderate` to classify user-submitted text or images for potentially harmful content before saving, publishing, or sending it into another AI call.
+
+A common use case is checking a comment before it is shown publicly:
 
 ```ruby
-result = ai.moderate("User submitted text")
+comment = "User submitted comment"
+result = ai.moderate(comment)
 
 if result["content"]["flagged"]
-  # hide, block, or route to review
+  # hide, block, or route the comment to review
+else
+  # publish the comment
 end
 ```
 
+Moderation responses include an overall `flagged` value plus category booleans and scores:
+
+```ruby
+{
+  "content" => {
+    "flagged" => false,
+    "categories" => {
+      "hate" => false,
+      "violence" => false
+    },
+    "category_scores" => {
+      "hate" => 0.01,
+      "violence" => 0.02
+    }
+  },
+  "response_id" => "modr_...",
+  "status" => 200,
+  "error" => nil,
+  "raw" => nil
+}
+```
+
 `moderate` sends a `POST` request to `/v1/moderations` with:
 
 - `model`
@@ -144,6 +175,135 @@ result = ai.moderate([
 ])
 ```
 
+## Embeddings
+
+Use `embed` to turn text into vectors that can be stored and compared for semantic search, recommendations, duplicate detection, or retrieval-augmented generation.
+
+```ruby
+result = ai.embed("How do I reset my password?")
+vector = result["content"]
+```
+
+For one string input, `content` is the embedding vector:
+
+```ruby
+{
+  "content" => [0.012, -0.44, 0.203],
+  "response_id" => nil,
+  "status" => 200,
+  "error" => nil,
+  "raw" => nil
+}
+```
+
+For multiple inputs, `content` is an array of vectors in the same order:
+
+```ruby
+result = ai.embed([
+  "How do I reset my password?",
+  "How do I update my billing card?"
+])
+
+vectors = result["content"]
+first_vector = vectors[0]
+```
+
+```ruby
+{
+  "content" => [
+    [0.012, -0.44, 0.203],
+    [0.332, 0.021, -0.118]
+  ],
+  "response_id" => nil,
+  "status" => 200,
+  "error" => nil,
+  "raw" => nil
+}
+```
+
+`embed` sends a `POST` request to `/v1/embeddings` with:
+
+- `model`
+- `input`
+- optional `dimensions`
+- optional `encoding_format`
+- optional `debug`
+- optional extra `options`
+
+The default embedding model is `text-embedding-3-small`.
+
+Pass `debug: true` to include the raw OpenAI response, including token usage:
+
+```ruby
+result = ai.embed("Hello", debug: true)
+
+result["content"]       # embedding vector
+result["raw"]["usage"]  # token usage
+```
+
+## Images
+
+Use `image` to generate an image from a prompt.
+
+```ruby
+result = ai.image("A clean Ruby gem logo on a white background")
+image_data = result["content"]
+```
+
+By default, `content` is the base64-encoded generated image:
+
+```ruby
+{
+  "content" => "iVBORw0KGgo...",
+  "response_id" => nil,
+  "status" => 200,
+  "error" => nil,
+  "raw" => nil
+}
+```
+
+Write the generated image bytes directly to a file with `output_path`:
+
+```ruby
+result = ai.image(
+  "A clean Ruby gem logo on a white background",
+  output_path: "tmp/logo.png"
+)
+```
+
+`image` sends a `POST` request to `/v1/images/generations` with:
+
+- `model`
+- `prompt`
+- optional `size`
+- optional `quality`
+- optional `background`
+- optional `output_format`
+- optional `debug`
+- optional extra `options`
+
+The default image model is `gpt-image-2`.
+
+Use `output_format` to request `png`, `webp`, or `jpeg` output:
+
+```ruby
+result = ai.image(
+  "A transparent app icon",
+  background: "transparent",
+  output_format: "webp",
+  output_path: "tmp/icon.webp"
+)
+```
+
+Pass `debug: true` to include the raw OpenAI response, including usage when returned:
+
+```ruby
+result = ai.image("A tiny robot sticker", debug: true)
+
+result["content"]       # base64 image data
+result["raw"]["usage"]  # token usage, when returned
+```
+
 ## Multi-Turn Chat
 
 Responses include a `response_id` that can be passed back through `options` as `previous_response_id`:
@@ -189,22 +349,6 @@ JSON-looking model output:
 }
 ```
 
-Moderation output:
-
-```ruby
-{
-  "content" => {
-    "flagged" => false,
-    "categories" => { ... },
-    "category_scores" => { ... }
-  },
-  "response_id" => "modr_...",
-  "status" => 200,
-  "error" => nil,
-  "raw" => nil
-}
-```
-
 Failure:
 
 ```ruby

data/lib/ai_lite/version.rb

@@ -1,3 +1,3 @@
 class AiLite
-  VERSION = "0.2.0".freeze
+  VERSION = "0.4.0".freeze
 end

data/lib/ai_lite.rb

@@ -8,6 +8,8 @@ class AiLite
   API_BASE_URL = "https://api.openai.com/v1".freeze
   DEFAULT_MODEL = "gpt-5.5".freeze
   DEFAULT_MODERATION_MODEL = "omni-moderation-latest".freeze
+  DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small".freeze
+  DEFAULT_IMAGE_MODEL = "gpt-image-2".freeze
   DEFAULT_TIMEOUT = 120
   DEFAULT_MAX_OUTPUT_TOKENS = 2000
   IMAGE_MIME_TYPES = {
@@ -19,12 +21,14 @@ class AiLite
   }.freeze
 
   class Configuration
-    attr_accessor :api_key, :model, :moderation_model, :timeout, :max_output_tokens
+    attr_accessor :api_key, :model, :moderation_model, :embedding_model, :image_model, :timeout, :max_output_tokens
 
     def initialize
       @api_key = nil
       @model = DEFAULT_MODEL
       @moderation_model = DEFAULT_MODERATION_MODEL
+      @embedding_model = DEFAULT_EMBEDDING_MODEL
+      @image_model = DEFAULT_IMAGE_MODEL
       @timeout = DEFAULT_TIMEOUT
       @max_output_tokens = DEFAULT_MAX_OUTPUT_TOKENS
     end
@@ -59,19 +63,29 @@ class AiLite
       client.moderate(input, **kwargs)
     end
 
+    def embed(input, **kwargs)
+      client.embed(input, **kwargs)
+    end
+
+    def image(prompt, **kwargs)
+      client.image(prompt, **kwargs)
+    end
+
     def reset_client!
       @client = nil
     end
   end
 
-  attr_reader :api_key, :model, :moderation_model, :timeout, :max_output_tokens, :headers
+  attr_reader :api_key, :model, :moderation_model, :embedding_model, :image_model, :timeout, :max_output_tokens, :headers
 
-  def initialize(api_key: nil, model: nil, moderation_model: nil, timeout: nil, max_output_tokens: nil)
+  def initialize(api_key: nil, model: nil, moderation_model: nil, embedding_model: nil, image_model: nil, timeout: nil, max_output_tokens: nil)
     @api_key = api_key || self.class.configuration.api_key || ENV["OPENAI_API_KEY"] || ENV["OPEN_AI_TOKEN"]
     raise ArgumentError, "Missing OpenAI API key" if @api_key.to_s.strip.empty?
 
     @model = model || self.class.configuration.model
     @moderation_model = moderation_model || self.class.configuration.moderation_model
+    @embedding_model = embedding_model || self.class.configuration.embedding_model
+    @image_model = image_model || self.class.configuration.image_model
     @timeout = timeout || self.class.configuration.timeout
     @max_output_tokens = max_output_tokens || self.class.configuration.max_output_tokens
     @headers = {
@@ -104,6 +118,34 @@ class AiLite
     prettify_data(status: "unknown", error: e.message, raw: nil, debug: debug)
   end
 
+  def embed(input, model: nil, dimensions: nil, encoding_format: nil, debug: false, options: {})
+    payload = options.merge(
+      model: model || embedding_model,
+      input: input
+    )
+    payload[:dimensions] = dimensions if dimensions
+    payload[:encoding_format] = encoding_format if encoding_format
+
+    extract_embedding(post(payload, endpoint: embedding_endpoint), multiple: input.is_a?(Array), debug: debug)
+  rescue => e
+    prettify_data(status: "unknown", error: e.message, raw: nil, debug: debug)
+  end
+
+  def image(prompt, model: nil, size: nil, quality: nil, background: nil, output_format: nil, output_path: nil, debug: false, options: {})
+    payload = options.merge(
+      model: model || image_model,
+      prompt: prompt
+    )
+    payload[:size] = size if size
+    payload[:quality] = quality if quality
+    payload[:background] = background if background
+    payload[:output_format] = output_format if output_format
+
+    extract_image(post(payload, endpoint: image_endpoint), output_path: output_path, debug: debug)
+  rescue => e
+    prettify_data(status: "unknown", error: e.message, raw: nil, debug: debug)
+  end
+
   private
 
   def post(payload, endpoint: response_endpoint)
@@ -131,6 +173,14 @@ class AiLite
     "#{API_BASE_URL}/moderations"
   end
 
+  def embedding_endpoint
+    "#{API_BASE_URL}/embeddings"
+  end
+
+  def image_endpoint
+    "#{API_BASE_URL}/images/generations"
+  end
+
   def extract_content(response, debug: false)
     status = response.code.to_i
     parsed_response = JSON.parse(response.body)
@@ -187,6 +237,63 @@ class AiLite
     prettify_data(status: response_status(response), error: e.message, raw: nil, debug: debug)
   end
 
+  def extract_embedding(response, multiple:, debug: false)
+    status = response.code.to_i
+    parsed_response = JSON.parse(response.body)
+
+    unless success_status?(status)
+      return prettify_data(
+        status: status,
+        error: error_message(parsed_response),
+        response_id: parsed_response["id"],
+        raw: parsed_response,
+        debug: debug
+      )
+    end
+
+    prettify_data(
+      status: status,
+      content: embedding_content(parsed_response, multiple: multiple),
+      response_id: parsed_response["id"],
+      raw: parsed_response,
+      debug: debug
+    )
+  rescue JSON::ParserError => e
+    prettify_data(status: response_status(response), error: e.message, raw: response&.body, debug: debug)
+  rescue => e
+    prettify_data(status: response_status(response), error: e.message, raw: nil, debug: debug)
+  end
+
+  def extract_image(response, output_path:, debug: false)
+    status = response.code.to_i
+    parsed_response = JSON.parse(response.body)
+
+    unless success_status?(status)
+      return prettify_data(
+        status: status,
+        error: error_message(parsed_response),
+        response_id: parsed_response["id"],
+        raw: parsed_response,
+        debug: debug
+      )
+    end
+
+    content = image_content(parsed_response)
+    write_image_output(output_path, content) if output_path
+
+    prettify_data(
+      status: status,
+      content: content,
+      response_id: parsed_response["id"],
+      raw: parsed_response,
+      debug: debug
+    )
+  rescue JSON::ParserError => e
+    prettify_data(status: response_status(response), error: e.message, raw: response&.body, debug: debug)
+  rescue => e
+    prettify_data(status: response_status(response), error: e.message, raw: nil, debug: debug)
+  end
+
   def extract_output_text(raw)
     Array(raw["output"]).flat_map do |item|
       next [] unless item.is_a?(Hash) && item["type"] == "message"
@@ -253,6 +360,25 @@ class AiLite
     results.length == 1 ? results.first : results
   end
 
+  def embedding_content(raw, multiple:)
+    embeddings = Array(raw["data"]).map do |item|
+      item["embedding"] if item.is_a?(Hash)
+    end.compact
+
+    multiple ? embeddings : embeddings.first
+  end
+
+  def image_content(raw)
+    image = Array(raw["data"]).find { |item| item.is_a?(Hash) && item["b64_json"] }
+    image && image["b64_json"]
+  end
+
+  def write_image_output(path, content)
+    raise "No image data returned" if content.to_s.empty?
+
+    File.binwrite(path, Base64.decode64(content))
+  end
+
   def success_status?(status)
     status >= 200 && status < 300
   end

data/test/ai_lite_test.rb

@@ -33,12 +33,15 @@ class AiLiteTest < Minitest::Test
       client = AiLite.new(
         api_key: "explicit-key",
         model: "gpt-test",
+        image_model: "gpt-image-test",
         timeout: 10
       )
 
       assert_equal "explicit-key", client.api_key
       assert_equal "gpt-test", client.model
       assert_equal "omni-moderation-latest", client.moderation_model
+      assert_equal "text-embedding-3-small", client.embedding_model
+      assert_equal "gpt-image-test", client.image_model
       assert_equal 10, client.timeout
       assert_equal 2000, client.max_output_tokens
       assert_equal "Bearer explicit-key", client.headers["Authorization"]
@@ -52,6 +55,8 @@ class AiLiteTest < Minitest::Test
         config.api_key = "configured-key"
         config.model = "gpt-config"
         config.moderation_model = "omni-moderation-test"
+        config.embedding_model = "text-embedding-test"
+        config.image_model = "gpt-image-test"
         config.timeout = 15
         config.max_output_tokens = 750
       end
@@ -61,6 +66,8 @@ class AiLiteTest < Minitest::Test
       assert_equal "configured-key", client.api_key
       assert_equal "gpt-config", client.model
       assert_equal "omni-moderation-test", client.moderation_model
+      assert_equal "text-embedding-test", client.embedding_model
+      assert_equal "gpt-image-test", client.image_model
       assert_equal 15, client.timeout
       assert_equal 750, client.max_output_tokens
       assert_same client, AiLite.client
@@ -83,6 +90,8 @@ class AiLiteTest < Minitest::Test
       config.api_key = "configured-key"
       config.model = "gpt-config"
       config.moderation_model = "omni-moderation-config"
+      config.embedding_model = "text-embedding-config"
+      config.image_model = "gpt-image-config"
       config.timeout = 15
       config.max_output_tokens = 750
     end
@@ -91,6 +100,8 @@ class AiLiteTest < Minitest::Test
       api_key: "explicit-key",
       model: "gpt-explicit",
       moderation_model: "omni-moderation-explicit",
+      embedding_model: "text-embedding-explicit",
+      image_model: "gpt-image-explicit",
       timeout: 5,
       max_output_tokens: 300
     )
@@ -98,6 +109,8 @@ class AiLiteTest < Minitest::Test
     assert_equal "explicit-key", client.api_key
     assert_equal "gpt-explicit", client.model
     assert_equal "omni-moderation-explicit", client.moderation_model
+    assert_equal "text-embedding-explicit", client.embedding_model
+    assert_equal "gpt-image-explicit", client.image_model
     assert_equal 5, client.timeout
     assert_equal 300, client.max_output_tokens
   end
@@ -427,6 +440,210 @@ class AiLiteTest < Minitest::Test
     assert_nil result["raw"]
   end
 
+  def test_embed_sends_post_to_embeddings_with_default_payload
+    client = AiLite.new(api_key: "token-abc")
+
+    with_stubbed_http(embedding_response([[0.12, -0.34, 0.56]])) do |captured, _response|
+      result = client.embed("Text to vectorize")
+      request = captured[:http].last_request
+      payload = JSON.parse(request.body)
+
+      assert_equal [0.12, -0.34, 0.56], result["content"]
+      assert_nil result["response_id"]
+      assert_equal 200, result["status"]
+      assert_nil result["error"]
+      assert_nil result["raw"]
+      assert_equal "api.openai.com", captured[:host]
+      assert_equal 443, captured[:port]
+      assert_equal true, captured[:use_ssl]
+      assert_instance_of Net::HTTP::Post, request
+      assert_equal "/v1/embeddings", request.path
+      assert_equal "Bearer token-abc", request["Authorization"]
+      assert_equal "application/json", request["Content-Type"]
+      assert_equal "text-embedding-3-small", payload["model"]
+      assert_equal "Text to vectorize", payload["input"]
+    end
+  end
+
+  def test_embed_returns_vector_list_for_multiple_inputs
+    client = AiLite.new(api_key: "token-abc")
+    embeddings = [
+      [0.11, 0.22, 0.33],
+      [0.44, 0.55, 0.66]
+    ]
+
+    with_stubbed_http(embedding_response(embeddings)) do |captured, _response|
+      result = client.embed(["First text", "Second text"])
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal ["First text", "Second text"], payload["input"]
+      assert_equal embeddings, result["content"]
+      assert_equal 200, result["status"]
+      assert_nil result["error"]
+    end
+  end
+
+  def test_embed_includes_options_dimensions_encoding_format_and_model
+    client = AiLite.new(api_key: "token-abc")
+
+    with_stubbed_http(embedding_response([[0.12, -0.34]])) do |captured, _response|
+      client.embed(
+        "Short text",
+        model: "text-embedding-3-large",
+        dimensions: 2,
+        encoding_format: "float",
+        options: {
+          user: "user-123"
+        }
+      )
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal "text-embedding-3-large", payload["model"]
+      assert_equal "Short text", payload["input"]
+      assert_equal 2, payload["dimensions"]
+      assert_equal "float", payload["encoding_format"]
+      assert_equal "user-123", payload["user"]
+    end
+  end
+
+  def test_embed_uses_class_level_configured_client
+    AiLite.configure do |config|
+      config.api_key = "configured-key"
+      config.embedding_model = "text-embedding-config"
+    end
+
+    with_stubbed_http(embedding_response([[0.12, -0.34, 0.56]])) do |captured, _response|
+      AiLite.embed("Use configured defaults")
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal "text-embedding-config", payload["model"]
+      assert_equal "Bearer configured-key", captured[:http].last_request["Authorization"]
+    end
+  end
+
+  def test_embed_debug_true_returns_raw_usage
+    client = AiLite.new(api_key: "token-abc")
+
+    with_stubbed_http(embedding_response([[0.12, -0.34, 0.56]])) do |_captured, _response|
+      result = client.embed("Text to vectorize", debug: true)
+
+      assert_equal [0.12, -0.34, 0.56], result["content"]
+      assert_equal({ "prompt_tokens" => 4, "total_tokens" => 4 }, result["raw"]["usage"])
+    end
+  end
+
+  def test_image_sends_post_to_images_with_default_payload
+    client = AiLite.new(api_key: "token-abc")
+    image_data = Base64.strict_encode64("fake image")
+
+    with_stubbed_http(image_response(b64_json: image_data)) do |captured, _response|
+      result = client.image("A small ruby gem logo")
+      request = captured[:http].last_request
+      payload = JSON.parse(request.body)
+
+      assert_equal image_data, result["content"]
+      assert_nil result["response_id"]
+      assert_equal 200, result["status"]
+      assert_nil result["error"]
+      assert_nil result["raw"]
+      assert_equal "api.openai.com", captured[:host]
+      assert_equal 443, captured[:port]
+      assert_equal true, captured[:use_ssl]
+      assert_instance_of Net::HTTP::Post, request
+      assert_equal "/v1/images/generations", request.path
+      assert_equal "Bearer token-abc", request["Authorization"]
+      assert_equal "application/json", request["Content-Type"]
+      assert_equal "gpt-image-2", payload["model"]
+      assert_equal "A small ruby gem logo", payload["prompt"]
+    end
+  end
+
+  def test_image_includes_options_size_quality_background_output_format_and_model
+    client = AiLite.new(api_key: "token-abc")
+
+    with_stubbed_http(image_response) do |captured, _response|
+      client.image(
+        "A transparent app icon",
+        model: "gpt-image-test",
+        size: "1024x1536",
+        quality: "high",
+        background: "transparent",
+        output_format: "webp",
+        options: {
+          moderation: "auto",
+          output_compression: 80
+        }
+      )
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal "gpt-image-test", payload["model"]
+      assert_equal "A transparent app icon", payload["prompt"]
+      assert_equal "1024x1536", payload["size"]
+      assert_equal "high", payload["quality"]
+      assert_equal "transparent", payload["background"]
+      assert_equal "webp", payload["output_format"]
+      assert_equal "auto", payload["moderation"]
+      assert_equal 80, payload["output_compression"]
+    end
+  end
+
+  def test_image_uses_class_level_configured_client
+    AiLite.configure do |config|
+      config.api_key = "configured-key"
+      config.image_model = "gpt-image-config"
+    end
+
+    with_stubbed_http(image_response) do |captured, _response|
+      AiLite.image("Use configured defaults")
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal "gpt-image-config", payload["model"]
+      assert_equal "Bearer configured-key", captured[:http].last_request["Authorization"]
+    end
+  end
+
+  def test_image_writes_decoded_content_to_output_path
+    client = AiLite.new(api_key: "token-abc")
+    image_data = Base64.strict_encode64("fake image")
+
+    Tempfile.create(["generated", ".png"]) do |file|
+      with_stubbed_http(image_response(b64_json: image_data)) do |_captured, _response|
+        result = client.image("A file output", output_path: file.path)
+
+        assert_equal image_data, result["content"]
+        assert_equal "fake image", File.binread(file.path)
+      end
+    end
+  end
+
+  def test_image_debug_true_returns_raw_usage
+    client = AiLite.new(api_key: "token-abc")
+    image_data = Base64.strict_encode64("fake image")
+
+    with_stubbed_http(image_response(b64_json: image_data)) do |_captured, _response|
+      result = client.image("A debuggable image", debug: true)
+
+      assert_equal image_data, result["content"]
+      assert_equal({ "input_tokens" => 10, "output_tokens" => 20, "total_tokens" => 30 }, result["raw"]["usage"])
+    end
+  end
+
+  def test_image_output_path_without_image_data_returns_standard_envelope
+    client = AiLite.new(api_key: "token-abc")
+
+    Tempfile.create(["generated", ".png"]) do |file|
+      with_stubbed_http(image_response(b64_json: nil)) do |_captured, _response|
+        result = client.image("A missing image", output_path: file.path)
+
+        assert_nil result["content"]
+        assert_nil result["response_id"]
+        assert_equal 200, result["status"]
+        assert_equal "No image data returned", result["error"]
+        assert_nil result["raw"]
+      end
+    end
+  end
+
   def test_http_errors_return_standard_envelope
     client = AiLite.new(api_key: "token-abc")
     body = JSON.generate("error" => { "message" => "Invalid API key" })
@@ -542,6 +759,45 @@ class AiLiteTest < Minitest::Test
     }
   end
 
+  def embedding_response(embeddings)
+    body = JSON.generate(
+      "object" => "list",
+      "data" => embeddings.each_with_index.map do |embedding, index|
+        {
+          "object" => "embedding",
+          "index" => index,
+          "embedding" => embedding
+        }
+      end,
+      "model" => "text-embedding-3-small",
+      "usage" => {
+        "prompt_tokens" => 4,
+        "total_tokens" => 4
+      }
+    )
+    FakeResponse.new("200", body)
+  end
+
+  def image_response(b64_json: Base64.strict_encode64("fake image"))
+    image = {}
+    image["b64_json"] = b64_json if b64_json
+
+    body = JSON.generate(
+      "created" => 1_713_833_628,
+      "background" => "opaque",
+      "data" => [image],
+      "output_format" => "png",
+      "quality" => "medium",
+      "size" => "1024x1024",
+      "usage" => {
+        "input_tokens" => 10,
+        "output_tokens" => 20,
+        "total_tokens" => 30
+      }
+    )
+    FakeResponse.new("200", body)
+  end
+
   def with_env(values)
     originals = {}
 

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: ai-lite
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - William Basmayor
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-19 00:00:00.000000000 Z
+date: 2026-08-04 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 Responses API calls.
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -27,7 +27,7 @@ homepage: https://github.com/wbasmayor/ai-lite
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -42,8 +42,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Minimal Ruby client for simple AI chat calls through the OpenAI Responses
   API.