typesafe-jev 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 331918548db2a5fdbd2f3dc3c2ac3bf650ff80d530e1bf5df205ddabede2299b
-  data.tar.gz: ce1c7bef8487e643d53fcfa8cb338fdb4abd26a085c19478e50cb53eac01d336
+  metadata.gz: 7545ebcb0bdc5d72f1038ae64b4305c3d5aeb6110b0b5e53b0c37cb88de77ee5
+  data.tar.gz: 50b7471d5f3c5c5dad8c1c4b14c0dbc3f2b062fe0ee7e4cd076d2ff44b4b46e0
 SHA512:
-  metadata.gz: 18dee0e01b1df600771dcc3eff223841f7074df76f309494dbdfc3b200ff6db4cc6627c6ce8cd0a3934665302385b07986e6a66f3bd96b51af3126f61d95e823
-  data.tar.gz: cb4261224cfec035eed1b1bac36a02f84cc388a9ff05997aff7d9bc59a35a31108465eb6bd277cd94c0296408321ae17c8c8883b41718b1d95a9b363236ec120
+  metadata.gz: 3d8c3637a1d48b857019ac364b7aca9875cf0accad92023021a02f00488569b518c685afceccb8c117e98bf72e80f63eae3469d632b213c745e7b6b7fd88a4ca
+  data.tar.gz: f4f8167797e08f99b23a0faa879ffe10e7d01370487e4c18d4472ef52256835df82c63426c37bb8d847672502f71902624f375520108880447880aace31c00ba

data/CHANGELOG.md

@@ -1,30 +1,76 @@
 # Changelog
 
-## 0.6.0
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-09-20
+
+### Added
+
+- Full MIT `LICENSE` text, a complete README (quickstart, question/answer/error guide), a `CONTRIBUTING.md` guide and GitHub issue templates.
+- Gemspec metadata: `documentation_uri` (rubydoc.info) and `rubygems_mfa_required`; homepage now points at the GitHub repository.
+
+### Changed
+
+- **Stability**: the public API shipped in 0.7.0 is now declared stable and covered by Semantic Versioning; breaking changes will require a major version bump from here on.
+
+## [0.7.0] - 2026-09-20
+
+### Changed
+
+- **Breaking**: `Typesafe::Client#evaluate` (and `Typesafe::Jev.evaluate`) now raises typed `Typesafe::Error` subclasses on any non-2xx response instead of raw `Net::HTTPClientException`/`Net::HTTPFatalError`: `BadRequestError` (400), `AuthenticationError` (401), `PermissionDeniedError` (403), `NotFoundError` (404), `UnprocessableEntityError` (422, with `#errors`), `RateLimitError` (429, with `#retry_after`), `OverloadedError` (529) and `ServerError` (5xx), all under the `Typesafe::APIError` base with `status`, `body`, `headers`, `request_id` and `#retryable?`. `Typesafe::Error` is the root rescuable class.
+
+## [0.6.0] - 2026-09-20
+
+### Changed
 
 - **Breaking**: `Typesafe::Client#evaluate` (and `Typesafe::Jev.evaluate`) now returns a typed `Typesafe::Response` instead of the raw parsed Hash; answers come back as `NoulAnswer`/`ChoiceAnswer`/`ScoreAnswer` objects accessible via `response[question_id]` (String or Symbol). Use `response.to_h` for the previous raw-Hash behavior.
 
-## 0.5.0
+## [0.5.0] - 2026-09-20
+
+### Added
+
+- Response classes mirroring the question classes: abstract `Typesafe::Answer` base with `Answer.from_h` dispatching on the `type` tag, plus `Typesafe::NoulAnswer` (`noul`), `Typesafe::ChoiceAnswer` (`choice`, `probabilities`, `confidence`) and `Typesafe::ScoreAnswer` (`score`, `legend`, `probabilities`, `confidence`). Frozen, immutable value objects that validate their inputs and serialize via `#to_h`/`#to_json`.
+- `Typesafe::Usage` (token counts) and `Typesafe::Response` (`model`, `answers`, `usage`), with `Response.from_json`/`from_h` to parse an API response body into typed Answer objects; `Response#[]` accepts String or Symbol question ids.
+
+## [0.4.1] - 2026-09-20
 
-- Add response classes mirroring the question classes: abstract `Typesafe::Answer` base with `Answer.from_h` dispatching on the `type` tag, plus `Typesafe::NoulAnswer` (`noul`), `Typesafe::ChoiceAnswer` (`choice`, `probabilities`, `confidence`) and `Typesafe::ScoreAnswer` (`score`, `legend`, `probabilities`, `confidence`). Frozen, immutable value objects that validate their inputs and serialize via `#to_h`/`#to_json`.
-- Add `Typesafe::Usage` (token counts) and `Typesafe::Response` (`model`, `answers`, `usage`), with `Response.from_json`/`from_h` to parse an API response body into typed Answer objects; `Response#[]` accepts String or Symbol question ids.
+### Fixed
 
-## 0.4.1
+- Gemspec metadata: point `source_code_uri`/`changelog_uri` and author/email at the `dtheofr` GitHub account.
 
-- Fix gemspec metadata: point `source_code_uri`/`changelog_uri` and author/email at the `dtheofr` GitHub account.
+## [0.4.0] - 2026-09-20
 
-## 0.4.0
+### Added
 
-- Add `Typesafe::Jev`, a `Typesafe::Client` subclass with the model pinned to `jev-latest`: `Jev.new(api_key: nil).evaluate(...)` plus a one-shot `Typesafe::Jev.evaluate(state:, questions:, api_key: nil)`.
+- `Typesafe::Jev`, a `Typesafe::Client` subclass with the model pinned to `jev-latest`: `Jev.new(api_key: nil).evaluate(...)` plus a one-shot `Typesafe::Jev.evaluate(state:, questions:, api_key: nil)`.
 
-## 0.3.0
+## [0.3.0] - 2026-09-20
 
-- Add `Typesafe::Client`: `initialize(api_key:, model:)` (key from argument or `TYPESAFE_API_KEY`, model defaults to `jev-latest`) and `evaluate(state:, questions:, model: nil)` posting to the System One endpoint. Returns the parsed JSON response; non-2xx responses raise the stdlib `Net::HTTP` error as-is.
+### Added
 
-## 0.2.0
+- `Typesafe::Client`: `initialize(api_key:, model:)` (key from argument or `TYPESAFE_API_KEY`, model defaults to `jev-latest`) and `evaluate(state:, questions:, model: nil)` posting to the System One endpoint. Returns the parsed JSON response; non-2xx responses raise the stdlib `Net::HTTP` error as-is.
 
-- Add question classes: `Typesafe::Noul`, `Typesafe::Choice`, `Typesafe::Score` with the abstract `Typesafe::Question` base. Frozen, immutable value objects that validate their inputs and serialize to the TypeSafe API shape via `#to_h`/`#to_json`.
+## [0.2.0] - 2026-09-20
 
-## 0.1.0
+### Added
+
+- Question classes: `Typesafe::Noul`, `Typesafe::Choice`, `Typesafe::Score` with the abstract `Typesafe::Question` base. Frozen, immutable value objects that validate their inputs and serialize to the TypeSafe API shape via `#to_h`/`#to_json`.
+
+## [0.1.0] - 2026-09-20
+
+### Added
 
 - Initial gem scaffold.
+
+[unreleased]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v0.7.0...v1.0.0
+[0.7.0]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v0.6.0...v0.7.0
+[0.6.0]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v0.4.1...v0.5.0
+[0.4.1]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/dtheofr/typesafe-jev-ruby/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/dtheofr/typesafe-jev-ruby/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dtheofr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,14 +1,147 @@
 # typesafe-jev
 
-Ruby client for [Jev](https://docs.typesafe.ai), TypeSafe's System One model — starting point, under construction.
+[![CI](https://github.com/dtheofr/typesafe-jev-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/dtheofr/typesafe-jev-ruby/actions/workflows/ci.yml)
+[![Gem Version](https://img.shields.io/gem/v/typesafe-jev?logo=rubygems&color=brightgreen)](https://rubygems.org/gems/typesafe-jev)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.1-red?logo=ruby)](https://rubygems.org/gems/typesafe-jev)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Ruby client for [Jev](https://docs.typesafe.ai), TypeSafe's System One model. Ask natural-language questions about your application state and get typed, probabilistic answers you can program against.
+
+**Zero runtime dependencies**: pure Ruby stdlib (`Net::HTTP`, `JSON`), so it works in plain Ruby and Rails alike.
+
+## Installation
+
+```sh
+gem install typesafe-jev
+```
+
+or in your `Gemfile`:
+
+```ruby
+gem "typesafe-jev"
+```
+
+## Quickstart
+
+```ruby
+require "typesafe"
+
+response = Typesafe::Jev.evaluate(
+  state: { ticket: { text: "My payouts failed twice this week." } },
+  questions: {
+    refund_requested: Typesafe::Noul.new("Does the customer request a refund?"),
+    category: Typesafe::Choice.new("Which category does this ticket belong to?", criteria: {
+      billing:   "Payment, invoices, refunds",
+      technical: "Bugs and outages",
+      sales:     "Pre-sales questions"
+    }),
+    severity: Typesafe::Score.new("How severe is this ticket?", criteria: [
+      "Low: routine request",
+      "Medium: degraded experience",
+      "High: blocked user",
+      "Critical: money lost or security issue"
+    ])
+  }
+)
+
+response[:refund_requested].noul  # => 0.95 (yes/no probability, 0..1)
+response[:category].choice        # => "billing"
+response[:category].probabilities # => { "billing" => 0.88, "technical" => 0.12, "sales" => 0.0 }
+response[:severity].score         # => "High: blocked user"
+response.usage.input_tokens       # => 296
+```
+
+`Typesafe::Jev.evaluate` is the one-shot facade with the model pinned to `jev-latest`. For another model, use `Typesafe::Client` directly.
+
+## Questions
+
+Questions are frozen, immutable value objects. The question **id is not in the object**; it is the Hash key in the `questions:` map, and answers come back under the same key.
+
+| Class | Answers with | Criteria |
+|---|---|---|
+| `Typesafe::Noul` | a yes/no probability (`noul`, 0..1) | optional `{ true: ..., false: ... }` |
+| `Typesafe::Choice` | one option + full probability distribution + `confidence` | non-empty `{ key: "description" }` |
+| `Typesafe::Score` | a level + `legend` + distribution + `confidence` | non-empty `["Level 1", "Level 2", ...]` |
+
+```ruby
+Typesafe::Noul.new("Does the customer request a refund?",
+  criteria: { true: "The customer explicitly asks for their money back",
+              false: "The customer does not mention refunds" })
+
+Typesafe::Choice.new("Which category does this ticket belong to?",
+  criteria: { billing: "Payment, invoices, refunds", technical: "Bugs and outages" })
+
+Typesafe::Score.new("How severe is this ticket?",
+  criteria: ["Low", "Medium", "High", "Critical"])
+```
+
+Invalid input raises `ArgumentError` at construction time, so bad questions fail fast, before any HTTP call.
+
+## Responses
+
+`Client#evaluate` returns a frozen `Typesafe::Response`:
+
+- `response[id]` (or `response.answers`): a typed `NoulAnswer`, `ChoiceAnswer` or `ScoreAnswer`; String and Symbol ids both work
+- `response.model`: the model that performed the evaluation
+- `response.usage`: `Typesafe::Usage` with `input_tokens` / `output_tokens`
+- `response.to_h` / `response.to_json`: the raw API shape
+
+Each answer type exposes its own accessors (`#noul`, `#choice`, `#probabilities`, `#confidence`, `#score`, `#legend`, …) and serializes via `#to_h`/`#to_json`.
+
+## Errors
+
+Any non-2xx HTTP response raises a typed error. All inherit from `Typesafe::APIError` (root: `Typesafe::Error`), which carries `#status`, `#body`, `#headers`, `#request_id` and `#retryable?`.
+
+| Error | Status | Extras |
+|---|---|---|
+| `Typesafe::BadRequestError` | 400 | |
+| `Typesafe::AuthenticationError` | 401 | |
+| `Typesafe::PermissionDeniedError` | 403 | |
+| `Typesafe::NotFoundError` | 404 | |
+| `Typesafe::UnprocessableEntityError` | 422 | `#errors` (validation details) |
+| `Typesafe::RateLimitError` | 429 | `#retry_after` |
+| `Typesafe::OverloadedError` | 529 | |
+| `Typesafe::ServerError` | 5xx | |
+
+```ruby
+begin
+  Typesafe::Jev.evaluate(state: state, questions: questions)
+rescue Typesafe::RateLimitError => e
+  sleep(e.retry_after || 1.0)
+  retry
+rescue Typesafe::OverloadedError
+  sleep(2**attempt)
+  retry
+rescue Typesafe::APIError => e
+  raise "typesafe request failed (#{e.status}, request #{e.request_id}): #{e.body}"
+end
+```
+
+## Configuration
+
+The API key is read from the `TYPESAFE_API_KEY` environment variable unless passed explicitly:
+
+```ruby
+jev = Typesafe::Jev.new                      # key from ENV
+jev = Typesafe::Jev.new(api_key: "sk-...")   # or explicit
+
+client = Typesafe::Client.new(api_key: "sk-...", model: "other-model")
+client.evaluate(state:, questions:, model: "one-off-model") # per-call override
+```
+
+## Documentation
+
+TypeSafe docs live at [docs.typesafe.ai](https://docs.typesafe.ai). The full API reference for this gem is on [rubydoc.info](https://rubydoc.info/gems/typesafe-jev).
 
 ## Development
 
 ```sh
 bundle install
-bundle exec rake test
+bundle exec rake spec   # or: bundle exec rspec
 ```
 
+The test suite runs against Ruby 3.1 and 3.4 in CI. See [CONTRIBUTING.md](CONTRIBUTING.md) for conventions.
+
 ## License
 
-MIT
+[MIT](LICENSE)

data/lib/typesafe/answer.rb

@@ -5,7 +5,7 @@ module Typesafe
   # System One API: {NoulAnswer}, {ChoiceAnswer}, and {ScoreAnswer}.
   #
   # An answer is an immutable value object mirroring its question: it carries
-  # what the model returned for one question, but not the question id — that
+  # what the model returned for one question, but not the question id; that
   # is the Hash key under which the answer appears in a {Response}.
   #
   # Use {Answer.from_h} (or {Response.from_json}) to build typed answers from

data/lib/typesafe/client.rb

@@ -55,8 +55,11 @@ module Typesafe
     #   String/Symbol keys to Question values, +model+ is invalid, or the
     #   response body is not a valid response shape.
     # @raise [JSON::ParserError] if the response body is not valid JSON.
-    # @raise [Net::HTTPClientException, Net::HTTPFatalError] on any non-2xx
-    #   HTTP response.
+    # @raise [Typesafe::APIError] (or a subclass) on any non-2xx HTTP response:
+    #   {Typesafe::BadRequestError}, {Typesafe::AuthenticationError},
+    #   {Typesafe::PermissionDeniedError}, {Typesafe::NotFoundError},
+    #   {Typesafe::UnprocessableEntityError}, {Typesafe::RateLimitError},
+    #   {Typesafe::OverloadedError} and {Typesafe::ServerError}.
     def evaluate(state:, questions:, model: nil)
       model = model.nil? ? self.model : freeze_string(model, "model must be a non-empty String")
       questions = validate_questions!(questions)
@@ -68,7 +71,10 @@ module Typesafe
       )
 
       response = post(body)
-      response.value
+      unless response.is_a?(Net::HTTPSuccess)
+        raise Errors.from_response(status: response.code.to_i, headers: response, body: response.body)
+      end
+
       Response.from_json(response.body)
     end
 

data/lib/typesafe/errors.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Typesafe
+  # Root of all errors raised by the gem, so users can `rescue Typesafe::Error`.
+  class Error < StandardError; end
+
+  # A non-2xx HTTP response from the TypeSafe API.
+  #
+  #   begin
+  #     client.evaluate(state:, questions:)
+  #   rescue Typesafe::RateLimitError => e
+  #     sleep(e.retry_after || 1.0)
+  #     retry
+  #   end
+  #
+  # The `detail` field of an error body comes in three shapes, all of which
+  # are rendered into the exception message:
+  #
+  # * a plain String: `{"detail": "Unknown model: jev-99"}`
+  # * a Hash with error_type/message:
+  #   `{"detail": {"error_type": "authentication_error", "message": "..."}}`
+  # * an Array of validation entries (FastAPI/pydantic style):
+  #   `{"detail": [{"type": "missing", "loc": ["body", "questions"], "msg": "Field required"}]}`
+  class APIError < Error
+    # @return [Integer] the HTTP status code.
+    attr_reader :status
+    # @return [Hash, Array, String, nil] the parsed JSON body (Hash or Array),
+    #   the raw body String when it is not valid JSON, or nil for an empty body.
+    attr_reader :body
+    # @return [Hash{String => String}] the response headers, as received.
+    attr_reader :headers
+    # @return [String, nil] the +x-typesafe-request-id+ response header, when present.
+    attr_reader :request_id
+
+    # @param status [Integer] the HTTP status code.
+    # @param body [Hash, Array, String, nil] the parsed or raw response body.
+    # @param headers [Hash{String => String}] the response headers.
+    # @param message [String, nil] overrides the rendered +detail+-based message.
+    def initialize(status:, body: nil, headers: {}, message: nil)
+      @status = status
+      @body = body
+      @headers = headers
+      @request_id = header("x-typesafe-request-id")
+      super(message || "The TypeSafe API returned status #{status}.")
+    end
+
+    # True when the request may succeed if retried after a delay: rate limits
+    # (429), overload (529) and server errors (5xx).
+    # @return [Boolean]
+    def retryable?
+      status == 429 || status == 529 || (500..599).cover?(status)
+    end
+
+    private
+
+    # Case-insensitive header lookup, since header casing depends on the server.
+    def header(name)
+      headers.each { |key, value| return value if key.to_s.downcase == name }
+      nil
+    end
+  end
+
+  # The request was invalid (400).
+  class BadRequestError < APIError; end
+
+  # Missing or invalid API key (401).
+  class AuthenticationError < APIError; end
+
+  # Access denied (403). The API also returns this for a missing API key.
+  class PermissionDeniedError < APIError; end
+
+  # The endpoint or resource was not found (404).
+  class NotFoundError < APIError; end
+
+  # The request body failed server-side validation (422).
+  class UnprocessableEntityError < APIError
+    # The parsed validation entries, e.g.
+    # `{"type" => "missing", "loc" => ["body", "questions"], "msg" => "Field required"}`;
+    # empty when the body carries none.
+    # @return [Array<Hash>]
+    def errors
+      detail = body.is_a?(Hash) ? body["detail"] : nil
+      detail.is_a?(Array) ? detail : []
+    end
+  end
+
+  # The rate limit was exceeded (429).
+  class RateLimitError < APIError
+    # The server's requested wait before retrying, parsed from the
+    # +Retry-After+ (seconds) or +Retry-After-Ms+ (milliseconds) header.
+    # @return [Float, Integer, nil]
+    def retry_after
+      if (ms = header("retry-after-ms"))
+        Float(ms) / 1000
+      elsif (seconds = header("retry-after"))
+        Float(seconds)
+      end
+    rescue ArgumentError, TypeError
+      nil
+    end
+  end
+
+  # TypeSafe is temporarily overloaded (529).
+  class OverloadedError < APIError; end
+
+  # The server failed to process the request (5xx, excluding 529).
+  class ServerError < APIError; end
+
+  # Builds error instances from raw HTTP responses.
+  module Errors
+    module_function
+
+    # Maps a non-2xx response to the matching error class.
+    #
+    # @param status [Integer] the HTTP status code.
+    # @param headers [Hash, #each_header] the response headers.
+    # @param body [String, Hash, Array, nil] the raw or parsed response body.
+    # @return [APIError] an instance of the class matching +status+.
+    def from_response(status:, headers: {}, body: nil)
+      parsed_body = parse_body(body)
+      klass = STATUS_CLASSES.fetch(status) do
+        (500..599).cover?(status) ? ServerError : APIError
+      end
+
+      klass.new(
+        status: status,
+        body: parsed_body.is_a?(String) ? parsed_body.dup.freeze : parsed_body.freeze,
+        headers: normalize_headers(headers).freeze,
+        message: message_from_body(parsed_body, status)
+      )
+    end
+
+    def parse_body(body)
+      return body unless body.is_a?(String)
+
+      JSON.parse(body)
+    rescue JSON::ParserError, TypeError
+      body
+    end
+
+    def message_from_body(parsed_body, status)
+      detail = parsed_body.is_a?(Hash) ? parsed_body["detail"] : nil
+      case detail
+      when String then detail
+      when Hash then detail["message"] || detail[:message] || "Invalid request."
+      when Array then detail.map { |entry| validation_message(entry) }.join("; ")
+      else "The TypeSafe API returned status #{status}."
+      end
+    end
+
+    def validation_message(entry)
+      return entry.to_s unless entry.is_a?(Hash)
+
+      loc = Array(entry["loc"]).join(".")
+      msg = entry["msg"] || entry[:msg]
+      loc.empty? ? msg.to_s : "#{loc}: #{msg}"
+    end
+
+    def normalize_headers(headers)
+      return headers.each_header.to_h if headers.respond_to?(:each_header)
+
+      headers.dup
+    rescue TypeError
+      {}
+    end
+
+    STATUS_CLASSES = {
+      400 => BadRequestError,
+      401 => AuthenticationError,
+      403 => PermissionDeniedError,
+      404 => NotFoundError,
+      422 => UnprocessableEntityError,
+      429 => RateLimitError,
+      529 => OverloadedError
+    }.freeze
+    private_constant :STATUS_CLASSES
+  end
+end

data/lib/typesafe/jev.rb

@@ -35,8 +35,8 @@ module Typesafe
     # @raise [ArgumentError] if +questions+ is invalid, +model+ is not the
     #   pinned one, or the response body is not a valid response shape.
     # @raise [JSON::ParserError] if the response body is not valid JSON.
-    # @raise [Net::HTTPClientException, Net::HTTPFatalError] on any non-2xx
-    #   HTTP response.
+    # @raise [Typesafe::APIError] (or a subclass) on any non-2xx HTTP response;
+    #   see {Typesafe::Client#evaluate}.
     def evaluate(state:, questions:, model: nil)
       if model && model != PINNED_MODEL
         raise ArgumentError,

data/lib/typesafe/response.rb

@@ -8,7 +8,7 @@ module Typesafe
   #   response = Typesafe::Response.from_json(json)
   #   response[:refund_requested] # => #<Typesafe::NoulAnswer @noul=0.95>
   #
-  # The answer objects do not carry their question id — it is the Hash key
+  # The answer objects do not carry their question id: it is the Hash key
   # under which each answer appears in {#answers}, mirroring how questions
   # are sent.
   class Response

data/lib/typesafe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Typesafe
-  VERSION = "0.6.0"
+  VERSION = "1.0.0"
 end

data/lib/typesafe.rb

@@ -16,6 +16,7 @@ require_relative "typesafe/score_answer"
 
 require_relative "typesafe/usage"
 require_relative "typesafe/response"
+require_relative "typesafe/errors"
 require_relative "typesafe/client"
 require_relative "typesafe/jev"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typesafe-jev
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - dtheofr
@@ -66,6 +66,7 @@ files:
 - lib/typesafe/choice.rb
 - lib/typesafe/choice_answer.rb
 - lib/typesafe/client.rb
+- lib/typesafe/errors.rb
 - lib/typesafe/jev.rb
 - lib/typesafe/noul.rb
 - lib/typesafe/noul_answer.rb
@@ -75,13 +76,15 @@ files:
 - lib/typesafe/score_answer.rb
 - lib/typesafe/usage.rb
 - lib/typesafe/version.rb
-homepage: https://docs.typesafe.ai
+homepage: https://github.com/dtheofr/typesafe-jev-ruby
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://docs.typesafe.ai
+  homepage_uri: https://github.com/dtheofr/typesafe-jev-ruby
   source_code_uri: https://github.com/dtheofr/typesafe-jev-ruby
   changelog_uri: https://github.com/dtheofr/typesafe-jev-ruby/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/typesafe-jev
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib