vellum_ai 0.3.14 → 0.14.74

data/lib/vellum_ai/types/generate_options_request.rb

@@ -1,50 +1,58 @@
 # frozen_string_literal: true
-
 require_relative "logprobs_enum"
+require "ostruct"
 require "json"
 
 module Vellum
   class GenerateOptionsRequest
-    attr_reader :logprobs, :additional_properties
+  # @return [Vellum::LogprobsEnum] Which logprobs to include, if any. Defaults to NONE.
+#  * `ALL` - ALL
+#  * `NONE` - NONE
+    attr_reader :logprobs
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param logprobs [LOGPROBS_ENUM] Which logprobs to include, if any. Defaults to NONE.
-    #   - `ALL` - ALL
-    #   - `NONE` - NONE
+    # @param logprobs [Vellum::LogprobsEnum] Which logprobs to include, if any. Defaults to NONE.
+#  * `ALL` - ALL
+#  * `NONE` - NONE
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [GenerateOptionsRequest]
-    def initialize(logprobs: nil, additional_properties: nil)
-      # @type [LOGPROBS_ENUM] Which logprobs to include, if any. Defaults to NONE.
-      #   - `ALL` - ALL
-      #   - `NONE` - NONE
-      @logprobs = logprobs
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::GenerateOptionsRequest]
+    def initialize(logprobs: OMIT, additional_properties: nil)
+      @logprobs = logprobs if logprobs != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "logprobs": logprobs }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of GenerateOptionsRequest
+# Deserialize a JSON object to an instance of GenerateOptionsRequest
     #
-    # @param json_object [JSON]
-    # @return [GenerateOptionsRequest]
+    # @param json_object [String] 
+    # @return [Vellum::GenerateOptionsRequest]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      logprobs = LOGPROBS_ENUM.key(parsed_json["logprobs"]) || parsed_json["logprobs"]
+      logprobs = parsed_json["logprobs"]
       new(logprobs: logprobs, additional_properties: struct)
     end
-
-    # Serialize an instance of GenerateOptionsRequest to a JSON object
+# Serialize an instance of GenerateOptionsRequest to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "logprobs": LOGPROBS_ENUM[@logprobs] || @logprobs }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
-      obj.logprobs&.is_a?(LOGPROBS_ENUM) != false || raise("Passed value for field obj.logprobs is not the expected type, validation failed.")
+      obj.logprobs&.is_a?(Vellum::LogprobsEnum) != false || raise("Passed value for field obj.logprobs is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/generate_request.rb

@@ -1,55 +1,73 @@
 # frozen_string_literal: true
-
 require_relative "chat_message_request"
+require "ostruct"
 require "json"
 
 module Vellum
   class GenerateRequest
-    attr_reader :input_values, :chat_history, :external_ids, :additional_properties
+  # @return [Hash{String => Object}] Key/value pairs for each template variable defined in the deployment's prompt.
+    attr_reader :input_values
+  # @return [Array<Vellum::ChatMessageRequest>] Optionally provide a list of chat messages that'll be used in place of the
+#  special chat_history variable, if included in the prompt.
+    attr_reader :chat_history
+  # @return [Array<String>] Optionally include a unique identifier for each generation, as represented
+#  outside of Vellum. Note that this should generally be a list of length one.
+    attr_reader :external_ids
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param input_values [Hash{String => String}] Key/value pairs for each template variable defined in the deployment's prompt.
-    # @param chat_history [Array<ChatMessageRequest>] Optionally provide a list of chat messages that'll be used in place of the special chat_history variable, if included in the prompt.
-    # @param external_ids [Array<String>] Optionally include a unique identifier for each generation, as represented outside of Vellum. Note that this should generally be a list of length one.
+    # @param input_values [Hash{String => Object}] Key/value pairs for each template variable defined in the deployment's prompt.
+    # @param chat_history [Array<Vellum::ChatMessageRequest>] Optionally provide a list of chat messages that'll be used in place of the
+#  special chat_history variable, if included in the prompt.
+    # @param external_ids [Array<String>] Optionally include a unique identifier for each generation, as represented
+#  outside of Vellum. Note that this should generally be a list of length one.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [GenerateRequest]
-    def initialize(input_values:, chat_history: nil, external_ids: nil, additional_properties: nil)
-      # @type [Hash{String => String}] Key/value pairs for each template variable defined in the deployment's prompt.
+    # @return [Vellum::GenerateRequest]
+    def initialize(input_values:, chat_history: OMIT, external_ids: OMIT, additional_properties: nil)
       @input_values = input_values
-      # @type [Array<ChatMessageRequest>] Optionally provide a list of chat messages that'll be used in place of the special chat_history variable, if included in the prompt.
-      @chat_history = chat_history
-      # @type [Array<String>] Optionally include a unique identifier for each generation, as represented outside of Vellum. Note that this should generally be a list of length one.
-      @external_ids = external_ids
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @chat_history = chat_history if chat_history != OMIT
+      @external_ids = external_ids if external_ids != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "input_values": input_values, "chat_history": chat_history, "external_ids": external_ids }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of GenerateRequest
+# Deserialize a JSON object to an instance of GenerateRequest
     #
-    # @param json_object [JSON]
-    # @return [GenerateRequest]
+    # @param json_object [String] 
+    # @return [Vellum::GenerateRequest]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      input_values = struct.input_values
-      chat_history = parsed_json["chat_history"].map do |v|
-        v = v.to_json
-        ChatMessageRequest.from_json(json_object: v)
-      end
-      external_ids = struct.external_ids
-      new(input_values: input_values, chat_history: chat_history, external_ids: external_ids,
-          additional_properties: struct)
+      input_values = parsed_json["input_values"]
+      chat_history = parsed_json["chat_history"]&.map do | item |
+  item = item.to_json
+  Vellum::ChatMessageRequest.from_json(json_object: item)
+end
+      external_ids = parsed_json["external_ids"]
+      new(
+        input_values: input_values,
+        chat_history: chat_history,
+        external_ids: external_ids,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of GenerateRequest to a JSON object
+# Serialize an instance of GenerateRequest to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "input_values": @input_values, "chat_history": @chat_history, "external_ids": @external_ids }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
       obj.input_values.is_a?(Hash) != false || raise("Passed value for field obj.input_values is not the expected type, validation failed.")
@@ -57,4 +75,4 @@ module Vellum
       obj.external_ids&.is_a?(Array) != false || raise("Passed value for field obj.external_ids is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/generate_response.rb

@@ -1,49 +1,55 @@
 # frozen_string_literal: true
-
 require_relative "generate_result"
+require "ostruct"
 require "json"
 
 module Vellum
   class GenerateResponse
-    attr_reader :results, :additional_properties
+  # @return [Array<Vellum::GenerateResult>] The results of each generation request.
+    attr_reader :results
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param results [Array<GenerateResult>] The results of each generation request.
+    # @param results [Array<Vellum::GenerateResult>] The results of each generation request.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [GenerateResponse]
+    # @return [Vellum::GenerateResponse]
     def initialize(results:, additional_properties: nil)
-      # @type [Array<GenerateResult>] The results of each generation request.
       @results = results
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "results": results }
     end
-
-    # Deserialize a JSON object to an instance of GenerateResponse
+# Deserialize a JSON object to an instance of GenerateResponse
     #
-    # @param json_object [JSON]
-    # @return [GenerateResponse]
+    # @param json_object [String] 
+    # @return [Vellum::GenerateResponse]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      results = parsed_json["results"].map do |v|
-        v = v.to_json
-        GenerateResult.from_json(json_object: v)
-      end
+      results = parsed_json["results"]&.map do | item |
+  item = item.to_json
+  Vellum::GenerateResult.from_json(json_object: item)
+end
       new(results: results, additional_properties: struct)
     end
-
-    # Serialize an instance of GenerateResponse to a JSON object
+# Serialize an instance of GenerateResponse to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "results": @results }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
       obj.results.is_a?(Array) != false || raise("Passed value for field obj.results is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/generate_result.rb

@@ -1,62 +1,79 @@
 # frozen_string_literal: true
-
 require_relative "generate_result_data"
 require_relative "generate_result_error"
+require "ostruct"
 require "json"
 
 module Vellum
   class GenerateResult
-    attr_reader :data, :error, :additional_properties
+  # @return [Vellum::GenerateResultData] An object containing the resulting generation. This key will be absent if the
+#  LLM provider experienced an error.
+    attr_reader :data
+  # @return [Vellum::GenerateResultError] An object containing details about the error that occurred. This key will be
+#  absent if the LLM provider did not experience an error.
+    attr_reader :error
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param data [GenerateResultData] An object containing the resulting generation. This key will be absent if the LLM provider experienced an error.
-    # @param error [GenerateResultError] An object containing details about the error that occurred. This key will be absent if the LLM provider did not experience an error.
+    # @param data [Vellum::GenerateResultData] An object containing the resulting generation. This key will be absent if the
+#  LLM provider experienced an error.
+    # @param error [Vellum::GenerateResultError] An object containing details about the error that occurred. This key will be
+#  absent if the LLM provider did not experience an error.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [GenerateResult]
-    def initialize(data: nil, error: nil, additional_properties: nil)
-      # @type [GenerateResultData] An object containing the resulting generation. This key will be absent if the LLM provider experienced an error.
-      @data = data
-      # @type [GenerateResultError] An object containing details about the error that occurred. This key will be absent if the LLM provider did not experience an error.
-      @error = error
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::GenerateResult]
+    def initialize(data: OMIT, error: OMIT, additional_properties: nil)
+      @data = data if data != OMIT
+      @error = error if error != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "data": data, "error": error }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of GenerateResult
+# Deserialize a JSON object to an instance of GenerateResult
     #
-    # @param json_object [JSON]
-    # @return [GenerateResult]
+    # @param json_object [String] 
+    # @return [Vellum::GenerateResult]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      if parsed_json["data"].nil?
-        data = nil
-      else
+      unless parsed_json["data"].nil?
         data = parsed_json["data"].to_json
-        data = GenerateResultData.from_json(json_object: data)
-      end
-      if parsed_json["error"].nil?
-        error = nil
+        data = Vellum::GenerateResultData.from_json(json_object: data)
       else
+        data = nil
+      end
+      unless parsed_json["error"].nil?
         error = parsed_json["error"].to_json
-        error = GenerateResultError.from_json(json_object: error)
+        error = Vellum::GenerateResultError.from_json(json_object: error)
+      else
+        error = nil
       end
-      new(data: data, error: error, additional_properties: struct)
+      new(
+        data: data,
+        error: error,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of GenerateResult to a JSON object
+# Serialize an instance of GenerateResult to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "data": @data, "error": @error }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
-      obj.data.nil? || GenerateResultData.validate_raw(obj: obj.data)
-      obj.error.nil? || GenerateResultError.validate_raw(obj: obj.error)
+      obj.data.nil? || Vellum::GenerateResultData.validate_raw(obj: obj.data)
+      obj.error.nil? || Vellum::GenerateResultError.validate_raw(obj: obj.error)
     end
   end
-end
+end

data/lib/vellum_ai/types/generate_result_data.rb

@@ -1,49 +1,55 @@
 # frozen_string_literal: true
-
 require_relative "enriched_normalized_completion"
+require "ostruct"
 require "json"
 
 module Vellum
   class GenerateResultData
-    attr_reader :completions, :additional_properties
+  # @return [Array<Vellum::EnrichedNormalizedCompletion>] The generated completions. This will generally be a list of length one.
+    attr_reader :completions
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param completions [Array<EnrichedNormalizedCompletion>] The generated completions. This will generally be a list of length one.
+    # @param completions [Array<Vellum::EnrichedNormalizedCompletion>] The generated completions. This will generally be a list of length one.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [GenerateResultData]
+    # @return [Vellum::GenerateResultData]
     def initialize(completions:, additional_properties: nil)
-      # @type [Array<EnrichedNormalizedCompletion>] The generated completions. This will generally be a list of length one.
       @completions = completions
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "completions": completions }
     end
-
-    # Deserialize a JSON object to an instance of GenerateResultData
+# Deserialize a JSON object to an instance of GenerateResultData
     #
-    # @param json_object [JSON]
-    # @return [GenerateResultData]
+    # @param json_object [String] 
+    # @return [Vellum::GenerateResultData]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      completions = parsed_json["completions"].map do |v|
-        v = v.to_json
-        EnrichedNormalizedCompletion.from_json(json_object: v)
-      end
+      completions = parsed_json["completions"]&.map do | item |
+  item = item.to_json
+  Vellum::EnrichedNormalizedCompletion.from_json(json_object: item)
+end
       new(completions: completions, additional_properties: struct)
     end
-
-    # Serialize an instance of GenerateResultData to a JSON object
+# Serialize an instance of GenerateResultData to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "completions": @completions }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
       obj.completions.is_a?(Array) != false || raise("Passed value for field obj.completions is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/generate_result_error.rb

@@ -1,45 +1,51 @@
 # frozen_string_literal: true
-
+require "ostruct"
 require "json"
 
 module Vellum
   class GenerateResultError
-    attr_reader :message, :additional_properties
+  # @return [String] The error message returned by the LLM provider.
+    attr_reader :message
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
     # @param message [String] The error message returned by the LLM provider.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [GenerateResultError]
+    # @return [Vellum::GenerateResultError]
     def initialize(message:, additional_properties: nil)
-      # @type [String] The error message returned by the LLM provider.
       @message = message
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "message": message }
     end
-
-    # Deserialize a JSON object to an instance of GenerateResultError
+# Deserialize a JSON object to an instance of GenerateResultError
     #
-    # @param json_object [JSON]
-    # @return [GenerateResultError]
+    # @param json_object [String] 
+    # @return [Vellum::GenerateResultError]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      JSON.parse(json_object)
-      message = struct.message
+      parsed_json = JSON.parse(json_object)
+      message = parsed_json["message"]
       new(message: message, additional_properties: struct)
     end
-
-    # Serialize an instance of GenerateResultError to a JSON object
+# Serialize an instance of GenerateResultError to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "message": @message }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
       obj.message.is_a?(String) != false || raise("Passed value for field obj.message is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/generate_stream_response.rb

@@ -1,51 +1,57 @@
 # frozen_string_literal: true
-
 require_relative "generate_stream_result"
+require "ostruct"
 require "json"
 
 module Vellum
   class GenerateStreamResponse
-    attr_reader :delta, :additional_properties
+  # @return [Vellum::GenerateStreamResult] 
+    attr_reader :delta
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param delta [GenerateStreamResult]
+    # @param delta [Vellum::GenerateStreamResult] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [GenerateStreamResponse]
+    # @return [Vellum::GenerateStreamResponse]
     def initialize(delta:, additional_properties: nil)
-      # @type [GenerateStreamResult]
       @delta = delta
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "delta": delta }
     end
-
-    # Deserialize a JSON object to an instance of GenerateStreamResponse
+# Deserialize a JSON object to an instance of GenerateStreamResponse
     #
-    # @param json_object [JSON]
-    # @return [GenerateStreamResponse]
+    # @param json_object [String] 
+    # @return [Vellum::GenerateStreamResponse]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      if parsed_json["delta"].nil?
-        delta = nil
-      else
+      unless parsed_json["delta"].nil?
         delta = parsed_json["delta"].to_json
-        delta = GenerateStreamResult.from_json(json_object: delta)
+        delta = Vellum::GenerateStreamResult.from_json(json_object: delta)
+      else
+        delta = nil
       end
       new(delta: delta, additional_properties: struct)
     end
-
-    # Serialize an instance of GenerateStreamResponse to a JSON object
+# Serialize an instance of GenerateStreamResponse to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "delta": @delta }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
-      GenerateStreamResult.validate_raw(obj: obj.delta)
+      Vellum::GenerateStreamResult.validate_raw(obj: obj.delta)
     end
   end
-end
+end