typesafe-jev 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7015c79f754569659d3e92b9d0fd456d60b3714541e6450a2aa1343cfec1d977
-  data.tar.gz: 22005ee9b9da3ddb490c7513f99dc04278c532ba1d2820440009344bad067762
+  metadata.gz: 331918548db2a5fdbd2f3dc3c2ac3bf650ff80d530e1bf5df205ddabede2299b
+  data.tar.gz: ce1c7bef8487e643d53fcfa8cb338fdb4abd26a085c19478e50cb53eac01d336
 SHA512:
-  metadata.gz: 758e26d12d4d88bf4b2abf741e9105987e3c9f261ecd7fa954d4230a53dcced8dfa1efe7b7549205fba4b4ebd584346c8e2975a5f03e4c38bdedad7073a28d77
-  data.tar.gz: 85f92ce2f585288bc75f6d8b80a9b1c4d2d9817c546a13030ed05821bf964147d63bae41b23b5e149508c7fd1868f720f10fca55ac61695acc95a785fb088844
+  metadata.gz: 18dee0e01b1df600771dcc3eff223841f7074df76f309494dbdfc3b200ff6db4cc6627c6ce8cd0a3934665302385b07986e6a66f3bd96b51af3126f61d95e823
+  data.tar.gz: cb4261224cfec035eed1b1bac36a02f84cc388a9ff05997aff7d9bc59a35a31108465eb6bd277cd94c0296408321ae17c8c8883b41718b1d95a9b363236ec120

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.6.0
+
+- **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
+
+- 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.
+
+## 0.4.1
+
+- Fix gemspec metadata: point `source_code_uri`/`changelog_uri` and author/email at the `dtheofr` GitHub account.
+
 ## 0.4.0
 
 - 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)`.

data/lib/typesafe/answer.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Typesafe
+  # Abstract base class for the three answer types returned by the 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
+  # 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
+  # a parsed response body:
+  #
+  #   Typesafe::Answer.from_h({ "type" => "noul", "noul" => 0.95 })
+  #   # => #<Typesafe::NoulAnswer @noul=0.95>
+  class Answer
+    # Builds the typed answer matching +hash+'s +type+ tag.
+    #
+    # @param hash [Hash] one entry of the API response's +answers+ map, with
+    #   String or Symbol keys.
+    # @return [NoulAnswer, ChoiceAnswer, ScoreAnswer]
+    # @raise [ArgumentError] if +hash+ is not a Hash or its +type+ is missing
+    #   or unknown.
+    def self.from_h(hash)
+      unless hash.is_a?(Hash)
+        raise ArgumentError, "answer must be a Hash, got #{hash.inspect}"
+      end
+
+      type = hash["type"] || hash[:type]
+      case type
+      when "noul" then NoulAnswer.from_h(hash)
+      when "choice" then ChoiceAnswer.from_h(hash)
+      when "score" then ScoreAnswer.from_h(hash)
+      else
+        raise ArgumentError,
+              "unknown answer type #{type.inspect} (expected \"noul\", \"choice\", or \"score\")"
+      end
+    end
+
+    # @return [String] the API answer type tag ("noul", "choice", or "score").
+    # @raise [NotImplementedError] on the abstract base class.
+    def type
+      raise NotImplementedError, "#{self.class} must implement #type"
+    end
+
+    # @return [Hash] the answer shape returned by the TypeSafe API.
+    def to_h
+      { type: type }
+    end
+
+    # @return [String] the answer serialized as JSON.
+    def to_json(state = nil)
+      JSON.generate(to_h, state)
+    end
+
+    # Answers compare equal when they are of the same class and serialize
+    # to the same API shape.
+    def ==(other)
+      other.class == self.class && other.to_h == to_h
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, to_h].hash
+    end
+
+    private
+
+    # Validates that +value+ is a non-empty String and returns a frozen copy.
+    def validate_string(value, name)
+      unless value.is_a?(String) && !value.strip.empty?
+        raise ArgumentError, "#{name} must be a non-empty String"
+      end
+
+      value.dup.freeze
+    end
+
+    # Validates that +value+ is a finite Numeric, optionally within +range+.
+    def validate_number(value, name, range: nil)
+      unless value.is_a?(Numeric) && value.finite?
+        raise ArgumentError, "#{name} must be a finite Numeric, got #{value.inspect}"
+      end
+
+      if range && !range.cover?(value)
+        raise ArgumentError, "#{name} must be between #{range.min} and #{range.max}, got #{value.inspect}"
+      end
+
+      value
+    end
+
+    # Validates that +value+ is a probability between 0 and 1.
+    def validate_probability(value, name)
+      validate_number(value, name, range: 0.0..1.0)
+    end
+
+    # Validates a probability distribution: a non-empty Hash with String or
+    # Symbol keys mapping to probabilities in 0..1 that sum to 1. When
+    # +allowed_keys+ is given, the keys must match it exactly.
+    def normalize_probabilities(probabilities, allowed_keys: nil)
+      unless probabilities.is_a?(Hash) && !probabilities.empty?
+        raise ArgumentError, "probabilities must be a non-empty Hash of option or level keys to probabilities"
+      end
+
+      normalized = probabilities.each_with_object({}) do |(key, probability), result|
+        unless key.is_a?(String) || key.is_a?(Symbol)
+          raise ArgumentError, "probabilities keys must be Strings or Symbols, got #{key.inspect}"
+        end
+
+        result[key.is_a?(String) ? key.dup.freeze : key] =
+          validate_probability(probability, "probabilities[#{key.inspect}]")
+      end
+
+      sum = normalized.values.sum
+      unless (sum - 1.0).abs <= 1e-6
+        raise ArgumentError, "probabilities must sum to 1, got #{sum}"
+      end
+
+      if allowed_keys
+        expected = allowed_keys.map(&:to_s)
+        actual = normalized.keys.map(&:to_s)
+        missing = expected - actual
+        unexpected = actual - expected
+        unless missing.empty? && unexpected.empty?
+          problems = []
+          problems << "missing #{missing.map(&:inspect).join(", ")}" unless missing.empty?
+          problems << "unexpected #{unexpected.map(&:inspect).join(", ")}" unless unexpected.empty?
+          raise ArgumentError, "probabilities keys must match the legend keys (#{problems.join("; ")})"
+        end
+      end
+
+      normalized.freeze
+    end
+  end
+end

data/lib/typesafe/choice_answer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Typesafe
+  # The answer to a {Choice} question: the selected option, the probability
+  # distribution across every option, and a confidence between 0 and 1.
+  #
+  #   Typesafe::ChoiceAnswer.new(
+  #     choice: "billing",
+  #     probabilities: { "billing" => 0.88, "technical" => 0.12, "sales" => 0.0 },
+  #     confidence: 0.81
+  #   )
+  class ChoiceAnswer < Answer
+    # @return [String] the highest-probability option.
+    attr_reader :choice
+
+    # @return [Hash] every option mapped to its probability.
+    attr_reader :probabilities
+
+    # @return [Numeric] how certain the model is, between 0 and 1.
+    attr_reader :confidence
+
+    # @param choice [String] the selected option.
+    # @param probabilities [Hash] option keys (String or Symbol) mapped to
+    #   probabilities in 0..1; the values must sum to 1.
+    # @param confidence [Numeric] the model's confidence, between 0 and 1.
+    # @raise [ArgumentError] if any attribute is invalid.
+    def initialize(choice:, probabilities:, confidence:)
+      @choice = validate_string(choice, "choice")
+      @probabilities = normalize_probabilities(probabilities)
+      @confidence = validate_probability(confidence, "confidence")
+      freeze
+    end
+
+    # @param hash [Hash] a +choice+ answer entry from the API response, with
+    #   String or Symbol keys.
+    # @return [ChoiceAnswer]
+    def self.from_h(hash)
+      new(
+        choice: hash["choice"] || hash[:choice],
+        probabilities: hash["probabilities"] || hash[:probabilities],
+        confidence: hash["confidence"] || hash[:confidence]
+      )
+    end
+
+    def type
+      "choice"
+    end
+
+    def to_h
+      { type: type, choice: choice, probabilities: probabilities, confidence: confidence }
+    end
+  end
+end

data/lib/typesafe/client.rb

@@ -40,8 +40,9 @@ module Typesafe
       freeze
     end
 
-    # Evaluates a state against a map of questions and returns the raw JSON
-    # response as a Hash, e.g. +{"model"=>..., "answers"=>{...}, "usage"=>...}+.
+    # Evaluates a state against a map of questions and returns a {Response}
+    # with one typed {Answer} per question, e.g. `response[:refund_requested]`.
+    # `response.to_h` gives the raw parsed body as a Hash.
     #
     # @param state [String, Object, Array] the content to evaluate; passed
     #   through as-is.
@@ -49,9 +50,11 @@ module Typesafe
     #   to Question objects; answers come back under the same keys.
     # @param model [String, nil] model for this call; falls back to the model
     #   given at initialization.
-    # @return [Hash] the parsed response body.
+    # @return [Response] the parsed response.
     # @raise [ArgumentError] if +questions+ is not a non-empty Hash of
-    #   String/Symbol keys to Question values, or +model+ is invalid.
+    #   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.
     def evaluate(state:, questions:, model: nil)
@@ -66,7 +69,7 @@ module Typesafe
 
       response = post(body)
       response.value
-      JSON.parse(response.body)
+      Response.from_json(response.body)
     end
 
     private

data/lib/typesafe/jev.rb

@@ -31,9 +31,10 @@ module Typesafe
     # @param questions [Hash{String, Symbol => Question}] question ids mapped
     #   to Question objects; answers come back under the same keys.
     # @param model [String, nil] must be nil or "jev-latest".
-    # @return [Hash] the parsed response body.
-    # @raise [ArgumentError] if +questions+ is invalid or +model+ is not the
-    #   pinned one.
+    # @return [Response] the parsed response.
+    # @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.
     def evaluate(state:, questions:, model: nil)
@@ -53,7 +54,7 @@ module Typesafe
     #   to Question objects.
     # @param api_key [String, nil] the TypeSafe API key; falls back to the
     #   +TYPESAFE_API_KEY+ environment variable.
-    # @return [Hash] the parsed response body.
+    # @return [Response] the parsed response.
     def self.evaluate(state:, questions:, api_key: nil)
       new(api_key: api_key).evaluate(state: state, questions: questions)
     end

data/lib/typesafe/noul_answer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Typesafe
+  # The answer to a {Noul} question: the yes/no probability on a scale from
+  # 0 (no) to 1 (yes).
+  #
+  #   Typesafe::NoulAnswer.new(noul: 0.95)
+  class NoulAnswer < Answer
+    # @return [Numeric] the yes/no answer, between 0 (no) and 1 (yes).
+    attr_reader :noul
+
+    # @param noul [Numeric] the yes/no probability, between 0 and 1.
+    # @raise [ArgumentError] if +noul+ is not a Numeric between 0 and 1.
+    def initialize(noul:)
+      @noul = validate_probability(noul, "noul")
+      freeze
+    end
+
+    # @param hash [Hash] a +noul+ answer entry from the API response, with
+    #   String or Symbol keys.
+    # @return [NoulAnswer]
+    def self.from_h(hash)
+      new(noul: hash["noul"] || hash[:noul])
+    end
+
+    def type
+      "noul"
+    end
+
+    def to_h
+      { type: type, noul: noul }
+    end
+  end
+end

data/lib/typesafe/response.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Typesafe
+  # A System One evaluation response: the model that performed the
+  # evaluation, one typed {Answer} per question (keyed by the question ids
+  # from the request), and the token {Usage}.
+  #
+  #   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
+  # under which each answer appears in {#answers}, mirroring how questions
+  # are sent.
+  class Response
+    # @return [String] the model that performed the evaluation.
+    attr_reader :model
+
+    # @return [Hash] question ids (String or Symbol) mapped to Answer objects.
+    attr_reader :answers
+
+    # @return [Usage] the token usage for the request.
+    attr_reader :usage
+
+    # @param model [String] the model that performed the evaluation.
+    # @param answers [Hash] question ids (String or Symbol) mapped to Answer
+    #   objects or answer Hashes; Hashes are parsed via {Answer.from_h}.
+    # @param usage [Usage, Hash] a Usage object, or a +usage+ Hash parsed
+    #   via {Usage.from_h}.
+    # @raise [ArgumentError] if any attribute is invalid or an answer is not
+    #   parseable.
+    def initialize(model:, answers:, usage:)
+      @model = freeze_string(model, "model must be a non-empty String")
+      @answers = normalize_answers(answers)
+      @usage = usage.is_a?(Usage) ? usage : Usage.from_h(usage)
+      freeze
+    end
+
+    # Parses a raw JSON response body from the TypeSafe API.
+    #
+    # @param json [String] the response body.
+    # @return [Response]
+    # @raise [ArgumentError] if the body is not a valid response shape.
+    # @raise [JSON::ParserError] if +json+ is not valid JSON.
+    def self.from_json(json)
+      from_h(JSON.parse(json))
+    end
+
+    # @param hash [Hash] the parsed response body, with String or Symbol keys.
+    # @return [Response]
+    # @raise [ArgumentError] if +hash+ is not a valid response shape.
+    def self.from_h(hash)
+      unless hash.is_a?(Hash)
+        raise ArgumentError, "response must be a Hash, got #{hash.inspect}"
+      end
+
+      new(
+        model: hash["model"] || hash[:model],
+        answers: hash["answers"] || hash[:answers],
+        usage: hash["usage"] || hash[:usage]
+      )
+    end
+
+    # The answer for a question id.
+    #
+    # @param id [String, Symbol] the question id used in the request.
+    # @return [Answer, nil] the matching answer, or nil if the id is unknown.
+    def [](id)
+      answers[id] || (id.is_a?(Symbol) ? answers[id.to_s] : nil)
+    end
+
+    # @return [Hash] the response shape returned by the TypeSafe API.
+    def to_h
+      { model: model, answers: answers.transform_values(&:to_h), usage: usage.to_h }
+    end
+
+    # @return [String] the response serialized as JSON.
+    def to_json(state = nil)
+      JSON.generate(to_h, state)
+    end
+
+    # Responses compare equal when they are of the same class and serialize
+    # to the same API shape.
+    def ==(other)
+      other.class == self.class && other.to_h == to_h
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, to_h].hash
+    end
+
+    private
+
+    # Validates that +model+ is a non-empty String and returns a frozen copy.
+    def freeze_string(value, error_message)
+      unless value.is_a?(String) && !value.strip.empty?
+        raise ArgumentError, error_message
+      end
+
+      value.dup.freeze
+    end
+
+    # Validates that +answers+ is a non-empty Hash of question ids to
+    # (or parseable) Answer objects, and freezes its keys.
+    def normalize_answers(answers)
+      unless answers.is_a?(Hash) && !answers.empty?
+        raise ArgumentError, "answers must be a non-empty Hash mapping question ids to answers"
+      end
+
+      answers.each_with_object({}) do |(id, answer), normalized|
+        unless (id.is_a?(String) && !id.strip.empty?) || (id.is_a?(Symbol) && !id.to_s.strip.empty?)
+          raise ArgumentError, "answers keys must be non-empty String or Symbol question ids, got #{id.inspect}"
+        end
+
+        normalized[id.is_a?(String) ? id.dup.freeze : id] =
+          if answer.is_a?(Answer)
+            answer
+          elsif answer.is_a?(Hash)
+            Answer.from_h(answer)
+          else
+            raise ArgumentError,
+                  "answers[#{id.inspect}] must be an answer Hash or Answer object, got #{answer.inspect}"
+          end
+      end.freeze
+    end
+  end
+end

data/lib/typesafe/score_answer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Typesafe
+  # The answer to a {Score} question: the probability-weighted value across
+  # the levels (which can land between two levels), the legend mapping each
+  # level back to its description, the probability distribution across
+  # levels, and a confidence between 0 and 1.
+  #
+  #   Typesafe::ScoreAnswer.new(
+  #     score: 1.6,
+  #     legend: { "1" => "Calm", "2" => "Frustrated", "3" => "Very angry" },
+  #     probabilities: { "1" => 0.6, "2" => 0.35, "3" => 0.05 },
+  #     confidence: 0.7
+  #   )
+  class ScoreAnswer < Answer
+    # @return [Numeric] the probability-weighted answer across the levels;
+    #   can land between levels.
+    attr_reader :score
+
+    # @return [Hash] each level number mapped back to its description.
+    attr_reader :legend
+
+    # @return [Hash] each level mapped to its probability; keys match the
+    #   legend.
+    attr_reader :probabilities
+
+    # @return [Numeric] how certain the model is, between 0 and 1.
+    attr_reader :confidence
+
+    # @param score [Numeric] the probability-weighted answer across levels.
+    # @param legend [Hash] level keys (String or Symbol) mapped to non-empty
+    #   String descriptions.
+    # @param probabilities [Hash] the same level keys mapped to probabilities
+    #   in 0..1; the values must sum to 1 and the keys must match +legend+.
+    # @param confidence [Numeric] the model's confidence, between 0 and 1.
+    # @raise [ArgumentError] if any attribute is invalid.
+    def initialize(score:, legend:, probabilities:, confidence:)
+      @score = validate_number(score, "score")
+      @legend = normalize_legend(legend)
+      @probabilities = normalize_probabilities(probabilities, allowed_keys: @legend.keys)
+      @confidence = validate_probability(confidence, "confidence")
+      freeze
+    end
+
+    # @param hash [Hash] a +score+ answer entry from the API response, with
+    #   String or Symbol keys.
+    # @return [ScoreAnswer]
+    def self.from_h(hash)
+      new(
+        score: hash["score"] || hash[:score],
+        legend: hash["legend"] || hash[:legend],
+        probabilities: hash["probabilities"] || hash[:probabilities],
+        confidence: hash["confidence"] || hash[:confidence]
+      )
+    end
+
+    def type
+      "score"
+    end
+
+    def to_h
+      { type: type, score: score, legend: legend, probabilities: probabilities, confidence: confidence }
+    end
+
+    private
+
+    # Validates that +legend+ is a non-empty Hash of level keys to
+    # non-empty String descriptions, with frozen copies of the descriptions.
+    def normalize_legend(legend)
+      unless legend.is_a?(Hash) && !legend.empty?
+        raise ArgumentError, "legend must be a non-empty Hash of level keys to descriptions"
+      end
+
+      legend.each_with_object({}) do |(key, description), normalized|
+        unless key.is_a?(String) || key.is_a?(Symbol)
+          raise ArgumentError, "legend keys must be Strings or Symbols, got #{key.inspect}"
+        end
+
+        normalized[key.is_a?(String) ? key.dup.freeze : key] =
+          validate_string(description, "legend[#{key.inspect}]")
+      end.freeze
+    end
+  end
+end

data/lib/typesafe/usage.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Typesafe
+  # Token usage for one evaluation request.
+  #
+  #   Typesafe::Usage.new(input_tokens: 296, output_tokens: 20)
+  class Usage
+    # @return [Integer] the number of input tokens.
+    attr_reader :input_tokens
+
+    # @return [Integer] the number of output tokens.
+    attr_reader :output_tokens
+
+    # @param input_tokens [Integer] the number of input tokens.
+    # @param output_tokens [Integer] the number of output tokens.
+    # @raise [ArgumentError] if a token count is not a non-negative Integer.
+    def initialize(input_tokens:, output_tokens:)
+      @input_tokens = validate_token_count(input_tokens, "input_tokens")
+      @output_tokens = validate_token_count(output_tokens, "output_tokens")
+      freeze
+    end
+
+    # @param hash [Hash] a +usage+ entry from the API response, with String
+    #   or Symbol keys.
+    # @return [Usage]
+    # @raise [ArgumentError] if +hash+ is not a Hash or a token count is
+    #   missing or invalid.
+    def self.from_h(hash)
+      unless hash.is_a?(Hash)
+        raise ArgumentError, "usage must be a Hash, got #{hash.inspect}"
+      end
+
+      new(
+        input_tokens: hash["input_tokens"] || hash[:input_tokens],
+        output_tokens: hash["output_tokens"] || hash[:output_tokens]
+      )
+    end
+
+    # @return [Hash] the +usage+ shape returned by the TypeSafe API.
+    def to_h
+      { input_tokens: input_tokens, output_tokens: output_tokens }
+    end
+
+    # Usages compare equal when their token counts match.
+    def ==(other)
+      other.class == self.class && other.to_h == to_h
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, to_h].hash
+    end
+
+    private
+
+    def validate_token_count(value, name)
+      unless value.is_a?(Integer) && value >= 0
+        raise ArgumentError, "#{name} must be a non-negative Integer, got #{value.inspect}"
+      end
+
+      value
+    end
+  end
+end

data/lib/typesafe/version.rb

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

data/lib/typesafe.rb

@@ -3,10 +3,19 @@
 require "json"
 
 require_relative "typesafe/version"
+
 require_relative "typesafe/question"
 require_relative "typesafe/noul"
 require_relative "typesafe/choice"
 require_relative "typesafe/score"
+
+require_relative "typesafe/answer"
+require_relative "typesafe/noul_answer"
+require_relative "typesafe/choice_answer"
+require_relative "typesafe/score_answer"
+
+require_relative "typesafe/usage"
+require_relative "typesafe/response"
 require_relative "typesafe/client"
 require_relative "typesafe/jev"
 

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: typesafe-jev
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
-- dtheo
+- dtheofr
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -53,7 +53,7 @@ dependencies:
         version: '3.0'
 description: Use Jev, TypeSafe's System One model, from Ruby or Rails.
 email:
-- dtheo@users.noreply.github.com
+- dtheofr@users.noreply.github.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -62,20 +62,26 @@ files:
 - LICENSE
 - README.md
 - lib/typesafe.rb
+- lib/typesafe/answer.rb
 - lib/typesafe/choice.rb
+- lib/typesafe/choice_answer.rb
 - lib/typesafe/client.rb
 - lib/typesafe/jev.rb
 - lib/typesafe/noul.rb
+- lib/typesafe/noul_answer.rb
 - lib/typesafe/question.rb
+- lib/typesafe/response.rb
 - lib/typesafe/score.rb
+- lib/typesafe/score_answer.rb
+- lib/typesafe/usage.rb
 - lib/typesafe/version.rb
 homepage: https://docs.typesafe.ai
 licenses:
 - MIT
 metadata:
   homepage_uri: https://docs.typesafe.ai
-  source_code_uri: https://github.com/dtheo/typesafe-jev-ruby
-  changelog_uri: https://github.com/dtheo/typesafe-jev-ruby/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/dtheofr/typesafe-jev-ruby
+  changelog_uri: https://github.com/dtheofr/typesafe-jev-ruby/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib