vellum_ai 0.3.15 → 0.14.74

data/lib/vellum_ai/types/prompt_output.rb

@@ -1,116 +1,90 @@
 # frozen_string_literal: true
-
 require "json"
-require_relative "string_variable_value"
-require_relative "json_variable_value"
-require_relative "error_variable_value"
-require_relative "function_call_variable_value"
+require_relative "string_vellum_value"
+require_relative "json_vellum_value"
+require_relative "error_vellum_value"
+require_relative "function_call_vellum_value"
 
 module Vellum
   class PromptOutput
-    attr_reader :member, :discriminant
 
-    private_class_method :new
-    alias kind_of? is_a?
-    # @param member [Object]
-    # @param discriminant [String]
-    # @return [PromptOutput]
-    def initialize(member:, discriminant:)
-      # @type [Object]
-      @member = member
-      # @type [String]
-      @discriminant = discriminant
-    end
 
-    # Deserialize a JSON object to an instance of PromptOutput
+# Deserialize a JSON object to an instance of PromptOutput
     #
-    # @param json_object [JSON]
-    # @return [PromptOutput]
+    # @param json_object [String] 
+    # @return [Vellum::PromptOutput]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      member = case struct.type
-               when "STRING"
-                 StringVariableValue.from_json(json_object: json_object)
-               when "JSON"
-                 JsonVariableValue.from_json(json_object: json_object)
-               when "ERROR"
-                 ErrorVariableValue.from_json(json_object: json_object)
-               when "FUNCTION_CALL"
-                 FunctionCallVariableValue.from_json(json_object: json_object)
-               else
-                 StringVariableValue.from_json(json_object: json_object)
-               end
-      new(member: member, discriminant: struct.type)
-    end
-
-    # For Union Types, to_json functionality is delegated to the wrapped member.
-    #
-    # @return [JSON]
-    def to_json(*_args)
-      case @discriminant
-      when "STRING"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "JSON"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "ERROR"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "FUNCTION_CALL"
-        { **@member.to_json, type: @discriminant }.to_json
-      else
-        { "type": @discriminant, value: @member }.to_json
+      begin
+        Vellum::StringVellumValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::StringVellumValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::JsonVellumValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::JsonVellumValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::ErrorVellumValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::ErrorVellumValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
       end
-      @member.to_json
+      begin
+        Vellum::FunctionCallVellumValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::FunctionCallVellumValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+ return struct
     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:)
-      case obj.type
-      when "STRING"
-        StringVariableValue.validate_raw(obj: obj)
-      when "JSON"
-        JsonVariableValue.validate_raw(obj: obj)
-      when "ERROR"
-        ErrorVariableValue.validate_raw(obj: obj)
-      when "FUNCTION_CALL"
-        FunctionCallVariableValue.validate_raw(obj: obj)
-      else
-        raise("Passed value matched no type within the union, validation failed.")
+      begin
+        return Vellum::StringVellumValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
       end
-    end
-
-    # For Union Types, is_a? functionality is delegated to the wrapped member.
-    #
-    # @param obj [Object]
-    # @return [Boolean]
-    def is_a?(obj)
-      @member.is_a?(obj)
-    end
-
-    # @param member [StringVariableValue]
-    # @return [PromptOutput]
-    def self.string(member:)
-      new(member: member, discriminant: "STRING")
-    end
-
-    # @param member [JsonVariableValue]
-    # @return [PromptOutput]
-    def self.json(member:)
-      new(member: member, discriminant: "JSON")
-    end
-
-    # @param member [ErrorVariableValue]
-    # @return [PromptOutput]
-    def self.error(member:)
-      new(member: member, discriminant: "ERROR")
-    end
-
-    # @param member [FunctionCallVariableValue]
-    # @return [PromptOutput]
-    def self.function_call(member:)
-      new(member: member, discriminant: "FUNCTION_CALL")
+      begin
+        return Vellum::JsonVellumValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::ErrorVellumValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::FunctionCallVellumValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      raise("Passed value matched no type within the union, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/prompt_parameters.rb

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

data/lib/vellum_ai/types/prompt_push_response.rb

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

data/lib/vellum_ai/types/prompt_request_chat_history_input.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require_relative "chat_message"
+require "ostruct"
+require "json"
+
+module Vellum
+  class PromptRequestChatHistoryInput
+  # @return [String] The variable's name, as defined in the Prompt.
+    attr_reader :key
+  # @return [String] 
+    attr_reader :type
+  # @return [Array<Vellum::ChatMessage>] 
+    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 key [String] The variable's name, as defined in the Prompt.
+    # @param type [String] 
+    # @param value [Array<Vellum::ChatMessage>] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::PromptRequestChatHistoryInput]
+    def initialize(key:, type:, value:, additional_properties: nil)
+      @key = key
+      @type = type
+      @value = value
+      @additional_properties = additional_properties
+      @_field_set = { "key": key, "type": type, "value": value }
+    end
+# Deserialize a JSON object to an instance of PromptRequestChatHistoryInput
+    #
+    # @param json_object [String] 
+    # @return [Vellum::PromptRequestChatHistoryInput]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      key = parsed_json["key"]
+      type = parsed_json["type"]
+      value = parsed_json["value"]&.map do | item |
+  item = item.to_json
+  Vellum::ChatMessage.from_json(json_object: item)
+end
+      new(
+        key: key,
+        type: type,
+        value: value,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of PromptRequestChatHistoryInput 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.key.is_a?(String) != false || raise("Passed value for field obj.key 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?(Array) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/prompt_request_input.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require "json"
+require_relative "prompt_request_string_input"
+require_relative "prompt_request_json_input"
+require_relative "prompt_request_chat_history_input"
+
+module Vellum
+  class PromptRequestInput
+
+
+# Deserialize a JSON object to an instance of PromptRequestInput
+    #
+    # @param json_object [String] 
+    # @return [Vellum::PromptRequestInput]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      begin
+        Vellum::PromptRequestStringInput.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::PromptRequestStringInput.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::PromptRequestJsonInput.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::PromptRequestJsonInput.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::PromptRequestChatHistoryInput.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::PromptRequestChatHistoryInput.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+ return struct
+    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:)
+      begin
+        return Vellum::PromptRequestStringInput.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::PromptRequestJsonInput.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::PromptRequestChatHistoryInput.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      raise("Passed value matched no type within the union, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/prompt_request_json_input.rb

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

data/lib/vellum_ai/types/prompt_request_string_input.rb

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