ai-lite 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6f864c2c29ee79c0aa144c940fa34a3a4b84189239436cab38fcd1862401726
-  data.tar.gz: 293507b5e1af278ab17658f81f63dc257a7d6ce2b00c79b77d64c6ba1e9fb434
+  metadata.gz: 2fbb65bf2c01cdc7950a76cc5a273c0b495174bb9d671f7b5d32d49a79274b34
+  data.tar.gz: e8e909ff9c107f552e1f6a81772b3800bb2b1904bf9a5da50cfe6a2ca2380bd4
 SHA512:
-  metadata.gz: 77bf79ade3eec73d1cbd06b269dd0d4566d4b06f96d7919dfa74a6f514572ff24fe36a93e65e9e43aa4a369e7c9a3db2e771e5c4419c8e22fc8f19d6f63db1af
-  data.tar.gz: 2033b7e8215841e2b57eb46355cef483e5badc30d56affffd1cd47b7e245442612fee91ec0918fda4828064fca7a7dc62e2268b329730ae0534e8ec07ed16aee
+  metadata.gz: ef2a0f01ea606b121b583134f6026c7d23388b3a58732a5a1f197275cb7178d2547ffea5040956955fd39452f944f1703833a4ba4925d0d2314ef2693372b904
+  data.tar.gz: 272108490b47700c06f49fb817d684fa6a2dbd003e02eff35fa59f19db8fe120e41983d941c32a50c640ef6776aee00038bc5ed841bef60cdde04fee854ea0c4

data/README.md

@@ -1,6 +1,6 @@
 # AI Lite
 
-AI Lite is a pure Ruby, dependency-light client for simple chat-style calls through OpenAI's Responses API.
+AI Lite is a pure Ruby, dependency-light client for simple OpenAI API calls.
 
 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.
 
@@ -11,12 +11,13 @@ This gem is intentionally small:
 - No Rails dependency
 - No official OpenAI gem dependency
 - No Faraday, HTTParty, ActiveSupport, or connection pool dependency
-- Uses only Ruby stdlib: `Net::HTTP`, `URI`, and `JSON`
+- Uses only Ruby stdlib: `Net::HTTP`, `URI`, `JSON`, and `Base64`
 
-It is not meant to replace the official OpenAI SDK. It is a small wrapper for projects that only need one clean interface:
+It is not meant to replace the official OpenAI SDK. It is a small wrapper for projects that only need a few clean interfaces:
 
 ```ruby
 ai.chat("Say hello")
+ai.moderate("User submitted text")
 ```
 
 ## Usage
@@ -47,6 +48,7 @@ In Rails, configure the default client from an initializer:
 AiLite.configure do |config|
   config.api_key = ENV["OPENAI_API_KEY"]
   config.model = "gpt-5.5"
+  config.moderation_model = "omni-moderation-latest"
   config.timeout = 120
   config.max_output_tokens = 2000
 end
@@ -91,15 +93,84 @@ The default model is `gpt-5.5`.
 
 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:
+
+```ruby
+result = ai.moderate("User submitted text")
+
+if result["content"]["flagged"]
+  # hide, block, or route to review
+end
+```
+
+`moderate` sends a `POST` request to `/v1/moderations` with:
+
+- `model`
+- `input`
+- optional extra `options`
+
+The default moderation model is `omni-moderation-latest`.
+
+You can pass an image URL:
+
+```ruby
+result = ai.moderate(
+  text: "Profile caption",
+  image_url: "https://example.com/image.png"
+)
+```
+
+Or a local image path:
+
+```ruby
+result = ai.moderate(image_path: "tmp/upload.png")
+```
+
+Local images are read, base64 encoded, and sent as JSON data URLs. They do not use multipart uploads. Supported local image extensions are `.gif`, `.jpeg`, `.jpg`, `.png`, and `.webp`.
+
+You can also pass OpenAI's raw moderation input shape directly:
+
+```ruby
+result = ai.moderate([
+  { type: "text", text: "Caption" },
+  {
+    type: "image_url",
+    image_url: {
+      url: "https://example.com/image.png"
+    }
+  }
+])
+```
+
+## Multi-Turn Chat
+
+Responses include a `response_id` that can be passed back through `options` as `previous_response_id`:
+
+```ruby
+first = ai.chat("Tell me a short joke.")
+
+follow_up = ai.chat(
+  "Explain why that is funny.",
+  options: {
+    previous_response_id: first["response_id"]
+  }
+)
+
+puts follow_up["content"]
+```
+
 ## Return Shape
 
-`chat` always returns a hash envelope.
+Methods return a hash envelope.
 
 Text output:
 
 ```ruby
 {
   "content" => "Hello!",
+  "response_id" => "resp_...",
   "status" => 200,
   "error" => nil,
   "raw" => nil
@@ -111,6 +182,23 @@ JSON-looking model output:
 ```ruby
 {
   "content" => { "valid" => true },
+  "response_id" => "resp_...",
+  "status" => 200,
+  "error" => nil,
+  "raw" => nil
+}
+```
+
+Moderation output:
+
+```ruby
+{
+  "content" => {
+    "flagged" => false,
+    "categories" => { ... },
+    "category_scores" => { ... }
+  },
+  "response_id" => "modr_...",
   "status" => 200,
   "error" => nil,
   "raw" => nil
@@ -122,6 +210,7 @@ Failure:
 ```ruby
 {
   "content" => nil,
+  "response_id" => nil,
   "status" => 401,
   "error" => "Invalid API key",
   "raw" => nil
@@ -135,6 +224,7 @@ result = ai.chat("Say hello", debug: true)
 
 {
   "content" => "Hello!",
+  "response_id" => "resp_...",
   "status" => 200,
   "error" => nil,
   "raw" => { ... }

data/lib/ai_lite/version.rb

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

data/lib/ai_lite.rb

@@ -1,3 +1,4 @@
+require "base64"
 require "json"
 require "net/http"
 require "uri"
@@ -6,15 +7,24 @@ require_relative "ai_lite/version"
 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_TIMEOUT = 120
   DEFAULT_MAX_OUTPUT_TOKENS = 2000
+  IMAGE_MIME_TYPES = {
+    ".gif" => "image/gif",
+    ".jpeg" => "image/jpeg",
+    ".jpg" => "image/jpeg",
+    ".png" => "image/png",
+    ".webp" => "image/webp"
+  }.freeze
 
   class Configuration
-    attr_accessor :api_key, :model, :timeout, :max_output_tokens
+    attr_accessor :api_key, :model, :moderation_model, :timeout, :max_output_tokens
 
     def initialize
       @api_key = nil
       @model = DEFAULT_MODEL
+      @moderation_model = DEFAULT_MODERATION_MODEL
       @timeout = DEFAULT_TIMEOUT
       @max_output_tokens = DEFAULT_MAX_OUTPUT_TOKENS
     end
@@ -45,18 +55,23 @@ class AiLite
       client.chat(message, **kwargs)
     end
 
+    def moderate(input = nil, **kwargs)
+      client.moderate(input, **kwargs)
+    end
+
     def reset_client!
       @client = nil
     end
   end
 
-  attr_reader :api_key, :model, :timeout, :max_output_tokens, :headers
+  attr_reader :api_key, :model, :moderation_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, moderation_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
     @timeout = timeout || self.class.configuration.timeout
     @max_output_tokens = max_output_tokens || self.class.configuration.max_output_tokens
     @headers = {
@@ -78,10 +93,21 @@ class AiLite
     prettify_data(status: "unknown", error: e.message, raw: nil, debug: debug)
   end
 
+  def moderate(input = nil, model: nil, text: nil, image_url: nil, image_path: nil, debug: false, options: {})
+    payload = options.merge(
+      model: model || moderation_model,
+      input: moderation_input(input, text: text, image_url: image_url, image_path: image_path)
+    )
+
+    extract_moderation(post(payload, endpoint: moderation_endpoint), debug: debug)
+  rescue => e
+    prettify_data(status: "unknown", error: e.message, raw: nil, debug: debug)
+  end
+
   private
 
-  def post(payload)
-    uri = URI.parse(response_endpoint)
+  def post(payload, endpoint: response_endpoint)
+    uri = URI.parse(endpoint)
     request = Net::HTTP::Post.new(uri)
 
     headers.each do |key, value|
@@ -101,17 +127,60 @@ class AiLite
     "#{API_BASE_URL}/responses"
   end
 
+  def moderation_endpoint
+    "#{API_BASE_URL}/moderations"
+  end
+
   def extract_content(response, 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), raw: parsed_response, debug: debug)
+      return prettify_data(
+        status: status,
+        error: error_message(parsed_response),
+        response_id: parsed_response["id"],
+        raw: parsed_response,
+        debug: debug
+      )
     end
 
     raw_content = extract_output_text(parsed_response)
     content = parse_content(raw_content)
-    prettify_data(status: status, content: content, raw: parsed_response, debug: debug)
+    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_moderation(response, 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: moderation_content(parsed_response),
+      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
@@ -138,6 +207,52 @@ class AiLite
     raw_text
   end
 
+  def moderation_input(input, text:, image_url:, image_path:)
+    unless text || image_url || image_path
+      raise ArgumentError, "Missing moderation input" if input.nil?
+
+      return input
+    end
+
+    items = []
+    items.concat(Array(input).map { |value| moderation_input_item(value) }) unless input.nil?
+    items << { type: "text", text: text } if text
+    items << { type: "image_url", image_url: { url: image_url } } if image_url
+    items << { type: "image_url", image_url: { url: image_data_url(image_path) } } if image_path
+    raise ArgumentError, "Missing moderation input" if items.empty?
+
+    items
+  end
+
+  def moderation_input_item(value)
+    case value
+    when String
+      { type: "text", text: value }
+    when Hash
+      value
+    else
+      raise ArgumentError, "Unsupported moderation input item: #{value.class}"
+    end
+  end
+
+  def image_data_url(path)
+    mime_type = image_mime_type(path)
+    "data:#{mime_type};base64,#{Base64.strict_encode64(File.binread(path))}"
+  end
+
+  def image_mime_type(path)
+    IMAGE_MIME_TYPES.fetch(File.extname(path).downcase) do
+      raise ArgumentError, "Unsupported image type for moderation: #{File.extname(path)}"
+    end
+  end
+
+  def moderation_content(raw)
+    results = raw["results"]
+    return nil unless results.is_a?(Array)
+
+    results.length == 1 ? results.first : results
+  end
+
   def success_status?(status)
     status >= 200 && status < 300
   end
@@ -154,9 +269,10 @@ class AiLite
     response&.code&.to_i || "unknown"
   end
 
-  def prettify_data(status:, content: nil, error: nil, raw:, debug: false)
+  def prettify_data(status:, content: nil, error: nil, response_id: nil, raw:, debug: false)
     {
       "content" => content,
+      "response_id" => response_id,
       "status" => status,
       "error" => error,
       "raw" => debug ? raw : nil

data/test/ai_lite_test.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "test_helper"
+require "tempfile"
 
 class AiLiteTest < Minitest::Test
   FakeResponse = Struct.new(:code, :body)
@@ -37,6 +38,7 @@ class AiLiteTest < Minitest::Test
 
       assert_equal "explicit-key", client.api_key
       assert_equal "gpt-test", client.model
+      assert_equal "omni-moderation-latest", client.moderation_model
       assert_equal 10, client.timeout
       assert_equal 2000, client.max_output_tokens
       assert_equal "Bearer explicit-key", client.headers["Authorization"]
@@ -49,6 +51,7 @@ class AiLiteTest < Minitest::Test
       AiLite.configure do |config|
         config.api_key = "configured-key"
         config.model = "gpt-config"
+        config.moderation_model = "omni-moderation-test"
         config.timeout = 15
         config.max_output_tokens = 750
       end
@@ -57,6 +60,7 @@ 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 15, client.timeout
       assert_equal 750, client.max_output_tokens
       assert_same client, AiLite.client
@@ -78,6 +82,7 @@ class AiLiteTest < Minitest::Test
     AiLite.configure do |config|
       config.api_key = "configured-key"
       config.model = "gpt-config"
+      config.moderation_model = "omni-moderation-config"
       config.timeout = 15
       config.max_output_tokens = 750
     end
@@ -85,12 +90,14 @@ class AiLiteTest < Minitest::Test
     client = AiLite.new(
       api_key: "explicit-key",
       model: "gpt-explicit",
+      moderation_model: "omni-moderation-explicit",
       timeout: 5,
       max_output_tokens: 300
     )
 
     assert_equal "explicit-key", client.api_key
     assert_equal "gpt-explicit", client.model
+    assert_equal "omni-moderation-explicit", client.moderation_model
     assert_equal 5, client.timeout
     assert_equal 300, client.max_output_tokens
   end
@@ -130,6 +137,7 @@ class AiLiteTest < Minitest::Test
       payload = JSON.parse(request.body)
 
       assert_equal "Hello!", result["content"]
+      assert_equal "resp_test_123", result["response_id"]
       assert_equal 200, result["status"]
       assert_nil result["error"]
       assert_nil result["raw"]
@@ -196,9 +204,28 @@ class AiLiteTest < Minitest::Test
     end
   end
 
+  def test_chat_supports_previous_response_id_through_options
+    client = AiLite.new(api_key: "token-abc")
+
+    with_stubbed_http(success_response("Follow-up")) do |captured, _response|
+      result = client.chat(
+        "Explain why that is funny",
+        options: {
+          previous_response_id: "resp_previous_123"
+        }
+      )
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal "resp_previous_123", payload["previous_response_id"]
+      assert_equal "Follow-up", result["content"]
+      assert_equal "resp_test_123", result["response_id"]
+    end
+  end
+
   def test_extracts_text_from_nested_output_text_items
     client = AiLite.new(api_key: "token-abc")
     body = JSON.generate(
+      "id" => "resp_nested_123",
       "output" => [
         { "type" => "reasoning", "content" => [] },
         {
@@ -215,6 +242,7 @@ class AiLiteTest < Minitest::Test
       result = client.chat("Say hello")
 
       assert_equal "Hello world", result["content"]
+      assert_equal "resp_nested_123", result["response_id"]
       assert_equal 200, result["status"]
       assert_nil result["error"]
     end
@@ -256,6 +284,149 @@ class AiLiteTest < Minitest::Test
     end
   end
 
+  def test_moderate_sends_post_to_moderations_with_default_payload
+    client = AiLite.new(api_key: "token-abc")
+
+    with_stubbed_http(moderation_response) do |captured, _response|
+      result = client.moderate("Some user submitted text")
+      request = captured[:http].last_request
+      payload = JSON.parse(request.body)
+
+      assert_equal false, result["content"]["flagged"]
+      assert_equal "modr_test_123", 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/moderations", request.path
+      assert_equal "Bearer token-abc", request["Authorization"]
+      assert_equal "application/json", request["Content-Type"]
+      assert_equal "omni-moderation-latest", payload["model"]
+      assert_equal "Some user submitted text", payload["input"]
+    end
+  end
+
+  def test_moderate_uses_class_level_configured_client
+    AiLite.configure do |config|
+      config.api_key = "configured-key"
+      config.moderation_model = "omni-moderation-config"
+    end
+
+    with_stubbed_http(moderation_response) do |captured, _response|
+      AiLite.moderate("Use configured defaults")
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal "omni-moderation-config", payload["model"]
+      assert_equal "Bearer configured-key", captured[:http].last_request["Authorization"]
+    end
+  end
+
+  def test_moderate_accepts_text_and_image_url_keywords
+    client = AiLite.new(api_key: "token-abc")
+
+    with_stubbed_http(moderation_response) do |captured, _response|
+      client.moderate(
+        text: "Profile caption",
+        image_url: "https://example.com/image.png"
+      )
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal(
+        [
+          { "type" => "text", "text" => "Profile caption" },
+          {
+            "type" => "image_url",
+            "image_url" => { "url" => "https://example.com/image.png" }
+          }
+        ],
+        payload["input"]
+      )
+    end
+  end
+
+  def test_moderate_accepts_raw_openai_input_shape
+    client = AiLite.new(api_key: "token-abc")
+    input = [
+      { type: "text", text: "Caption" },
+      {
+        type: "image_url",
+        image_url: {
+          url: "https://example.com/image.png"
+        }
+      }
+    ]
+
+    with_stubbed_http(moderation_response) do |captured, _response|
+      client.moderate(input)
+      payload = JSON.parse(captured[:http].last_request.body)
+
+      assert_equal(
+        [
+          { "type" => "text", "text" => "Caption" },
+          {
+            "type" => "image_url",
+            "image_url" => { "url" => "https://example.com/image.png" }
+          }
+        ],
+        payload["input"]
+      )
+    end
+  end
+
+  def test_moderate_reads_image_path_as_data_url
+    client = AiLite.new(api_key: "token-abc")
+
+    Tempfile.create(["moderation", ".png"]) do |file|
+      file.binmode
+      file.write("fake image")
+      file.flush
+
+      with_stubbed_http(moderation_response) do |captured, _response|
+        client.moderate(image_path: file.path)
+        payload = JSON.parse(captured[:http].last_request.body)
+
+        assert_equal(
+          [
+            {
+              "type" => "image_url",
+              "image_url" => { "url" => "data:image/png;base64,ZmFrZSBpbWFnZQ==" }
+            }
+          ],
+          payload["input"]
+        )
+      end
+    end
+  end
+
+  def test_moderate_returns_all_results_for_multiple_inputs
+    client = AiLite.new(api_key: "token-abc")
+    safe_result = moderation_result(flagged: false)
+    flagged_result = moderation_result(flagged: true)
+
+    with_stubbed_http(moderation_response(results: [safe_result, flagged_result])) do |_captured, _response|
+      result = client.moderate(["Safe text", "Risky text"])
+
+      assert_equal [safe_result, flagged_result], result["content"]
+      assert_equal 200, result["status"]
+      assert_nil result["error"]
+    end
+  end
+
+  def test_moderate_local_input_errors_return_standard_envelope
+    client = AiLite.new(api_key: "token-abc")
+
+    result = client.moderate
+
+    assert_nil result["content"]
+    assert_nil result["response_id"]
+    assert_equal "unknown", result["status"]
+    assert_equal "Missing moderation input", result["error"]
+    assert_nil result["raw"]
+  end
+
   def test_http_errors_return_standard_envelope
     client = AiLite.new(api_key: "token-abc")
     body = JSON.generate("error" => { "message" => "Invalid API key" })
@@ -264,6 +435,7 @@ class AiLiteTest < Minitest::Test
       result = client.chat("Say hello")
 
       assert_nil result["content"]
+      assert_nil result["response_id"]
       assert_equal 401, result["status"]
       assert_equal "Invalid API key", result["error"]
       assert_nil result["raw"]
@@ -291,6 +463,7 @@ class AiLiteTest < Minitest::Test
       result = client.chat("Say hello")
 
       assert_nil result["content"]
+      assert_nil result["response_id"]
       assert_equal 200, result["status"]
       assert_match(/unexpected token|unexpected character|parse/i, result["error"])
       assert_nil result["raw"]
@@ -321,6 +494,7 @@ class AiLiteTest < Minitest::Test
     result = client.chat("Say hello")
 
     assert_nil result["content"]
+    assert_nil result["response_id"]
     assert_equal "unknown", result["status"]
     assert_equal "connection failed", result["error"]
     assert_nil result["raw"]
@@ -332,6 +506,7 @@ class AiLiteTest < Minitest::Test
 
   def success_response(content)
     body = JSON.generate(
+      "id" => "resp_test_123",
       "output" => [
         {
           "type" => "message",
@@ -344,6 +519,29 @@ class AiLiteTest < Minitest::Test
     FakeResponse.new("200", body)
   end
 
+  def moderation_response(results: [moderation_result])
+    body = JSON.generate(
+      "id" => "modr_test_123",
+      "model" => "omni-moderation-latest",
+      "results" => results
+    )
+    FakeResponse.new("200", body)
+  end
+
+  def moderation_result(flagged: false)
+    {
+      "flagged" => flagged,
+      "categories" => {
+        "hate" => false,
+        "violence" => flagged
+      },
+      "category_scores" => {
+        "hate" => 0.01,
+        "violence" => flagged ? 0.95 : 0.02
+      }
+    }
+  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.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - William Basmayor
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-06-19 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.5.22
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Minimal Ruby client for simple AI chat calls through the OpenAI Responses
   API.