vellum_ai 0.3.14 → 0.14.74

data/lib/vellum_ai/types/normalized_token_log_probs.rb

@@ -1,55 +1,71 @@
 # frozen_string_literal: true
-
+require "ostruct"
 require "json"
 
 module Vellum
   class NormalizedTokenLogProbs
-    attr_reader :token, :logprob, :top_logprobs, :text_offset, :additional_properties
+  # @return [String] 
+    attr_reader :token
+  # @return [Float] 
+    attr_reader :logprob
+  # @return [Hash{String => Float}] 
+    attr_reader :top_logprobs
+  # @return [Integer] 
+    attr_reader :text_offset
+  # @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 token [String]
-    # @param logprob [Float]
-    # @param top_logprobs [Hash{String => String}]
-    # @param text_offset [Integer]
+    # @param token [String] 
+    # @param logprob [Float] 
+    # @param top_logprobs [Hash{String => Float}] 
+    # @param text_offset [Integer] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [NormalizedTokenLogProbs]
-    def initialize(token:, text_offset:, logprob: nil, top_logprobs: nil, additional_properties: nil)
-      # @type [String]
+    # @return [Vellum::NormalizedTokenLogProbs]
+    def initialize(token:, logprob: OMIT, top_logprobs: OMIT, text_offset:, additional_properties: nil)
       @token = token
-      # @type [Float]
-      @logprob = logprob
-      # @type [Hash{String => String}]
-      @top_logprobs = top_logprobs
-      # @type [Integer]
+      @logprob = logprob if logprob != OMIT
+      @top_logprobs = top_logprobs if top_logprobs != OMIT
       @text_offset = text_offset
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "token": token, "logprob": logprob, "top_logprobs": top_logprobs, "text_offset": text_offset }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of NormalizedTokenLogProbs
+# Deserialize a JSON object to an instance of NormalizedTokenLogProbs
     #
-    # @param json_object [JSON]
-    # @return [NormalizedTokenLogProbs]
+    # @param json_object [String] 
+    # @return [Vellum::NormalizedTokenLogProbs]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      JSON.parse(json_object)
-      token = struct.token
-      logprob = struct.logprob
-      top_logprobs = struct.top_logprobs
-      text_offset = struct.text_offset
-      new(token: token, logprob: logprob, top_logprobs: top_logprobs, text_offset: text_offset,
-          additional_properties: struct)
+      parsed_json = JSON.parse(json_object)
+      token = parsed_json["token"]
+      logprob = parsed_json["logprob"]
+      top_logprobs = parsed_json["top_logprobs"]
+      text_offset = parsed_json["text_offset"]
+      new(
+        token: token,
+        logprob: logprob,
+        top_logprobs: top_logprobs,
+        text_offset: text_offset,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of NormalizedTokenLogProbs to a JSON object
+# Serialize an instance of NormalizedTokenLogProbs to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "token": @token, "logprob": @logprob, "top_logprobs": @top_logprobs, "text_offset": @text_offset }.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.token.is_a?(String) != false || raise("Passed value for field obj.token is not the expected type, validation failed.")
@@ -58,4 +74,4 @@ module Vellum
       obj.text_offset.is_a?(Integer) != false || raise("Passed value for field obj.text_offset is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/number_input.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+
+module Vellum
+# A user input representing a number value
+  class NumberInput
+  # @return [String] The variable's name
+    attr_reader :name
+  # @return [String] 
+    attr_reader :type
+  # @return [Float] 
+    attr_reader :value
+  # @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 name [String] The variable's name
+    # @param type [String] 
+    # @param value [Float] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::NumberInput]
+    def initialize(name:, type:, value:, additional_properties: nil)
+      @name = name
+      @type = type
+      @value = value
+      @additional_properties = additional_properties
+      @_field_set = { "name": name, "type": type, "value": value }
+    end
+# Deserialize a JSON object to an instance of NumberInput
+    #
+    # @param json_object [String] 
+    # @return [Vellum::NumberInput]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      name = parsed_json["name"]
+      type = parsed_json["type"]
+      value = parsed_json["value"]
+      new(
+        name: name,
+        type: type,
+        value: value,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of NumberInput to a JSON object
+    #
+    # @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.
+    #
+    # @param obj [Object] 
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.value.is_a?(Float) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/number_vellum_value.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+
+module Vellum
+# A value representing a number.
+  class NumberVellumValue
+  # @return [String] 
+    attr_reader :type
+  # @return [Float] 
+    attr_reader :value
+  # @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 type [String] 
+    # @param value [Float] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::NumberVellumValue]
+    def initialize(type:, value: OMIT, additional_properties: nil)
+      @type = type
+      @value = value if value != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "type": type, "value": value }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of NumberVellumValue
+    #
+    # @param json_object [String] 
+    # @return [Vellum::NumberVellumValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      type = parsed_json["type"]
+      value = parsed_json["value"]
+      new(
+        type: type,
+        value: value,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of NumberVellumValue to a JSON object
+    #
+    # @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.
+    #
+    # @param obj [Object] 
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.value&.is_a?(Float) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/number_vellum_value_request.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+
+module Vellum
+# A value representing a number.
+  class NumberVellumValueRequest
+  # @return [String] 
+    attr_reader :type
+  # @return [Float] 
+    attr_reader :value
+  # @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 type [String] 
+    # @param value [Float] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::NumberVellumValueRequest]
+    def initialize(type:, value: OMIT, additional_properties: nil)
+      @type = type
+      @value = value if value != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "type": type, "value": value }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of NumberVellumValueRequest
+    #
+    # @param json_object [String] 
+    # @return [Vellum::NumberVellumValueRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      type = parsed_json["type"]
+      value = parsed_json["value"]
+      new(
+        type: type,
+        value: value,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of NumberVellumValueRequest to a JSON object
+    #
+    # @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.
+    #
+    # @param obj [Object] 
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.value&.is_a?(Float) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/open_ai_vectorizer_config.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+
+module Vellum
+# Configuration for using an OpenAI vectorizer.
+  class OpenAiVectorizerConfig
+  # @return [Boolean] 
+    attr_reader :add_openai_api_key
+  # @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 add_openai_api_key [Boolean] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::OpenAiVectorizerConfig]
+    def initialize(add_openai_api_key: OMIT, additional_properties: nil)
+      @add_openai_api_key = add_openai_api_key if add_openai_api_key != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "add_openai_api_key": add_openai_api_key }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of OpenAiVectorizerConfig
+    #
+    # @param json_object [String] 
+    # @return [Vellum::OpenAiVectorizerConfig]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      add_openai_api_key = parsed_json["add_openai_api_key"]
+      new(add_openai_api_key: add_openai_api_key, additional_properties: struct)
+    end
+# Serialize an instance of OpenAiVectorizerConfig to a JSON object
+    #
+    # @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.
+    #
+    # @param obj [Object] 
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.add_openai_api_key&.is_a?(Boolean) != false || raise("Passed value for field obj.add_openai_api_key is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/open_ai_vectorizer_config_request.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require "ostruct"
+require "json"
+
+module Vellum
+# Configuration for using an OpenAI vectorizer.
+  class OpenAiVectorizerConfigRequest
+  # @return [Boolean] 
+    attr_reader :add_openai_api_key
+  # @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 add_openai_api_key [Boolean] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::OpenAiVectorizerConfigRequest]
+    def initialize(add_openai_api_key: OMIT, additional_properties: nil)
+      @add_openai_api_key = add_openai_api_key if add_openai_api_key != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "add_openai_api_key": add_openai_api_key }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of OpenAiVectorizerConfigRequest
+    #
+    # @param json_object [String] 
+    # @return [Vellum::OpenAiVectorizerConfigRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      add_openai_api_key = parsed_json["add_openai_api_key"]
+      new(add_openai_api_key: add_openai_api_key, additional_properties: struct)
+    end
+# Serialize an instance of OpenAiVectorizerConfigRequest to a JSON object
+    #
+    # @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.
+    #
+    # @param obj [Object] 
+    # @return [Void]
+    def self.validate_raw(obj:)
+      obj.add_openai_api_key&.is_a?(Boolean) != false || raise("Passed value for field obj.add_openai_api_key is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/open_ai_vectorizer_text_embedding_3_large.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require_relative "open_ai_vectorizer_config"
+require "ostruct"
+require "json"
+
+module Vellum
+# OpenAI vectorizer for text-embedding-3-large.
+  class OpenAiVectorizerTextEmbedding3Large
+  # @return [Vellum::OpenAiVectorizerConfig] 
+    attr_reader :config
+  # @return [String] 
+    attr_reader :model_name
+  # @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 config [Vellum::OpenAiVectorizerConfig] 
+    # @param model_name [String] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::OpenAiVectorizerTextEmbedding3Large]
+    def initialize(config:, model_name:, additional_properties: nil)
+      @config = config
+      @model_name = model_name
+      @additional_properties = additional_properties
+      @_field_set = { "config": config, "model_name": model_name }
+    end
+# Deserialize a JSON object to an instance of OpenAiVectorizerTextEmbedding3Large
+    #
+    # @param json_object [String] 
+    # @return [Vellum::OpenAiVectorizerTextEmbedding3Large]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      unless parsed_json["config"].nil?
+        config = parsed_json["config"].to_json
+        config = Vellum::OpenAiVectorizerConfig.from_json(json_object: config)
+      else
+        config = nil
+      end
+      model_name = parsed_json["model_name"]
+      new(
+        config: config,
+        model_name: model_name,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of OpenAiVectorizerTextEmbedding3Large to a JSON object
+    #
+    # @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.
+    #
+    # @param obj [Object] 
+    # @return [Void]
+    def self.validate_raw(obj:)
+      Vellum::OpenAiVectorizerConfig.validate_raw(obj: obj.config)
+      obj.model_name.is_a?(String) != false || raise("Passed value for field obj.model_name is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/open_ai_vectorizer_text_embedding_3_large_request.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require_relative "open_ai_vectorizer_config_request"
+require "ostruct"
+require "json"
+
+module Vellum
+# OpenAI vectorizer for text-embedding-3-large.
+  class OpenAiVectorizerTextEmbedding3LargeRequest
+  # @return [Vellum::OpenAiVectorizerConfigRequest] 
+    attr_reader :config
+  # @return [String] 
+    attr_reader :model_name
+  # @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 config [Vellum::OpenAiVectorizerConfigRequest] 
+    # @param model_name [String] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::OpenAiVectorizerTextEmbedding3LargeRequest]
+    def initialize(config:, model_name:, additional_properties: nil)
+      @config = config
+      @model_name = model_name
+      @additional_properties = additional_properties
+      @_field_set = { "config": config, "model_name": model_name }
+    end
+# Deserialize a JSON object to an instance of
+#  OpenAiVectorizerTextEmbedding3LargeRequest
+    #
+    # @param json_object [String] 
+    # @return [Vellum::OpenAiVectorizerTextEmbedding3LargeRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      unless parsed_json["config"].nil?
+        config = parsed_json["config"].to_json
+        config = Vellum::OpenAiVectorizerConfigRequest.from_json(json_object: config)
+      else
+        config = nil
+      end
+      model_name = parsed_json["model_name"]
+      new(
+        config: config,
+        model_name: model_name,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of OpenAiVectorizerTextEmbedding3LargeRequest to a JSON
+#  object
+    #
+    # @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.
+    #
+    # @param obj [Object] 
+    # @return [Void]
+    def self.validate_raw(obj:)
+      Vellum::OpenAiVectorizerConfigRequest.validate_raw(obj: obj.config)
+      obj.model_name.is_a?(String) != false || raise("Passed value for field obj.model_name is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/open_ai_vectorizer_text_embedding_3_small.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require_relative "open_ai_vectorizer_config"
+require "ostruct"
+require "json"
+
+module Vellum
+# OpenAI vectorizer for text-embedding-3-small.
+  class OpenAiVectorizerTextEmbedding3Small
+  # @return [Vellum::OpenAiVectorizerConfig] 
+    attr_reader :config
+  # @return [String] 
+    attr_reader :model_name
+  # @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 config [Vellum::OpenAiVectorizerConfig] 
+    # @param model_name [String] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::OpenAiVectorizerTextEmbedding3Small]
+    def initialize(config:, model_name:, additional_properties: nil)
+      @config = config
+      @model_name = model_name
+      @additional_properties = additional_properties
+      @_field_set = { "config": config, "model_name": model_name }
+    end
+# Deserialize a JSON object to an instance of OpenAiVectorizerTextEmbedding3Small
+    #
+    # @param json_object [String] 
+    # @return [Vellum::OpenAiVectorizerTextEmbedding3Small]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      unless parsed_json["config"].nil?
+        config = parsed_json["config"].to_json
+        config = Vellum::OpenAiVectorizerConfig.from_json(json_object: config)
+      else
+        config = nil
+      end
+      model_name = parsed_json["model_name"]
+      new(
+        config: config,
+        model_name: model_name,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of OpenAiVectorizerTextEmbedding3Small to a JSON object
+    #
+    # @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.
+    #
+    # @param obj [Object] 
+    # @return [Void]
+    def self.validate_raw(obj:)
+      Vellum::OpenAiVectorizerConfig.validate_raw(obj: obj.config)
+      obj.model_name.is_a?(String) != false || raise("Passed value for field obj.model_name is not the expected type, validation failed.")
+    end
+  end
+end