vellum_ai 0.3.14 → 0.14.74

data/lib/vellum_ai/types/prompt_exec_config.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+require_relative "vellum_variable"
+require_relative "prompt_parameters"
+require_relative "prompt_settings"
+require_relative "prompt_block"
+require_relative "function_definition"
+require "ostruct"
+require "json"
+
+module Vellum
+  class PromptExecConfig
+  # @return [String] 
+    attr_reader :ml_model
+  # @return [Array<Vellum::VellumVariable>] 
+    attr_reader :input_variables
+  # @return [Vellum::PromptParameters] 
+    attr_reader :parameters
+  # @return [Vellum::PromptSettings] 
+    attr_reader :settings
+  # @return [Array<Vellum::PromptBlock>] 
+    attr_reader :blocks
+  # @return [Array<Vellum::FunctionDefinition>] 
+    attr_reader :functions
+  # @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 ml_model [String] 
+    # @param input_variables [Array<Vellum::VellumVariable>] 
+    # @param parameters [Vellum::PromptParameters] 
+    # @param settings [Vellum::PromptSettings] 
+    # @param blocks [Array<Vellum::PromptBlock>] 
+    # @param functions [Array<Vellum::FunctionDefinition>] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::PromptExecConfig]
+    def initialize(ml_model:, input_variables:, parameters:, settings: OMIT, blocks:, functions: OMIT, additional_properties: nil)
+      @ml_model = ml_model
+      @input_variables = input_variables
+      @parameters = parameters
+      @settings = settings if settings != OMIT
+      @blocks = blocks
+      @functions = functions if functions != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "ml_model": ml_model, "input_variables": input_variables, "parameters": parameters, "settings": settings, "blocks": blocks, "functions": functions }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of PromptExecConfig
+    #
+    # @param json_object [String] 
+    # @return [Vellum::PromptExecConfig]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      ml_model = parsed_json["ml_model"]
+      input_variables = parsed_json["input_variables"]&.map do | item |
+  item = item.to_json
+  Vellum::VellumVariable.from_json(json_object: item)
+end
+      unless parsed_json["parameters"].nil?
+        parameters = parsed_json["parameters"].to_json
+        parameters = Vellum::PromptParameters.from_json(json_object: parameters)
+      else
+        parameters = nil
+      end
+      unless parsed_json["settings"].nil?
+        settings = parsed_json["settings"].to_json
+        settings = Vellum::PromptSettings.from_json(json_object: settings)
+      else
+        settings = nil
+      end
+      blocks = parsed_json["blocks"]&.map do | item |
+  item = item.to_json
+  Vellum::PromptBlock.from_json(json_object: item)
+end
+      functions = parsed_json["functions"]&.map do | item |
+  item = item.to_json
+  Vellum::FunctionDefinition.from_json(json_object: item)
+end
+      new(
+        ml_model: ml_model,
+        input_variables: input_variables,
+        parameters: parameters,
+        settings: settings,
+        blocks: blocks,
+        functions: functions,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of PromptExecConfig 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.ml_model.is_a?(String) != false || raise("Passed value for field obj.ml_model is not the expected type, validation failed.")
+      obj.input_variables.is_a?(Array) != false || raise("Passed value for field obj.input_variables is not the expected type, validation failed.")
+      Vellum::PromptParameters.validate_raw(obj: obj.parameters)
+      obj.settings.nil? || Vellum::PromptSettings.validate_raw(obj: obj.settings)
+      obj.blocks.is_a?(Array) != false || raise("Passed value for field obj.blocks is not the expected type, validation failed.")
+      obj.functions&.is_a?(Array) != false || raise("Passed value for field obj.functions is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/prompt_execution_meta.rb

@@ -1,76 +1,113 @@
 # frozen_string_literal: true
-
 require_relative "finish_reason_enum"
+require_relative "ml_model_usage"
+require_relative "price"
+require "ostruct"
 require "json"
 
 module Vellum
-  # The subset of the metadata tracked by Vellum during prompt execution that the request opted into with `expand_meta`.
+# The subset of the metadata tracked by Vellum during prompt execution that the
+#  request opted into with `expand_meta`.
   class PromptExecutionMeta
-    attr_reader :model_name, :latency, :deployment_release_tag, :prompt_version_id, :finish_reason,
-                :additional_properties
+  # @return [String] 
+    attr_reader :model_name
+  # @return [Integer] 
+    attr_reader :latency
+  # @return [String] 
+    attr_reader :deployment_release_tag
+  # @return [String] 
+    attr_reader :prompt_version_id
+  # @return [Vellum::FinishReasonEnum] 
+    attr_reader :finish_reason
+  # @return [Vellum::MlModelUsage] 
+    attr_reader :usage
+  # @return [Vellum::Price] 
+    attr_reader :cost
+  # @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 model_name [String]
-    # @param latency [Integer]
-    # @param deployment_release_tag [String]
-    # @param prompt_version_id [String]
-    # @param finish_reason [FINISH_REASON_ENUM]
+    # @param model_name [String] 
+    # @param latency [Integer] 
+    # @param deployment_release_tag [String] 
+    # @param prompt_version_id [String] 
+    # @param finish_reason [Vellum::FinishReasonEnum] 
+    # @param usage [Vellum::MlModelUsage] 
+    # @param cost [Vellum::Price] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [PromptExecutionMeta]
-    def initialize(model_name: nil, latency: nil, deployment_release_tag: nil, prompt_version_id: nil,
-                   finish_reason: nil, additional_properties: nil)
-      # @type [String]
-      @model_name = model_name
-      # @type [Integer]
-      @latency = latency
-      # @type [String]
-      @deployment_release_tag = deployment_release_tag
-      # @type [String]
-      @prompt_version_id = prompt_version_id
-      # @type [FINISH_REASON_ENUM]
-      @finish_reason = finish_reason
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::PromptExecutionMeta]
+    def initialize(model_name: OMIT, latency: OMIT, deployment_release_tag: OMIT, prompt_version_id: OMIT, finish_reason: OMIT, usage: OMIT, cost: OMIT, additional_properties: nil)
+      @model_name = model_name if model_name != OMIT
+      @latency = latency if latency != OMIT
+      @deployment_release_tag = deployment_release_tag if deployment_release_tag != OMIT
+      @prompt_version_id = prompt_version_id if prompt_version_id != OMIT
+      @finish_reason = finish_reason if finish_reason != OMIT
+      @usage = usage if usage != OMIT
+      @cost = cost if cost != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "model_name": model_name, "latency": latency, "deployment_release_tag": deployment_release_tag, "prompt_version_id": prompt_version_id, "finish_reason": finish_reason, "usage": usage, "cost": cost }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of PromptExecutionMeta
+# Deserialize a JSON object to an instance of PromptExecutionMeta
     #
-    # @param json_object [JSON]
-    # @return [PromptExecutionMeta]
+    # @param json_object [String] 
+    # @return [Vellum::PromptExecutionMeta]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      model_name = struct.model_name
-      latency = struct.latency
-      deployment_release_tag = struct.deployment_release_tag
-      prompt_version_id = struct.prompt_version_id
-      finish_reason = FINISH_REASON_ENUM.key(parsed_json["finish_reason"]) || parsed_json["finish_reason"]
-      new(model_name: model_name, latency: latency, deployment_release_tag: deployment_release_tag,
-          prompt_version_id: prompt_version_id, finish_reason: finish_reason, additional_properties: struct)
+      model_name = parsed_json["model_name"]
+      latency = parsed_json["latency"]
+      deployment_release_tag = parsed_json["deployment_release_tag"]
+      prompt_version_id = parsed_json["prompt_version_id"]
+      finish_reason = parsed_json["finish_reason"]
+      unless parsed_json["usage"].nil?
+        usage = parsed_json["usage"].to_json
+        usage = Vellum::MlModelUsage.from_json(json_object: usage)
+      else
+        usage = nil
+      end
+      unless parsed_json["cost"].nil?
+        cost = parsed_json["cost"].to_json
+        cost = Vellum::Price.from_json(json_object: cost)
+      else
+        cost = nil
+      end
+      new(
+        model_name: model_name,
+        latency: latency,
+        deployment_release_tag: deployment_release_tag,
+        prompt_version_id: prompt_version_id,
+        finish_reason: finish_reason,
+        usage: usage,
+        cost: cost,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of PromptExecutionMeta to a JSON object
+# Serialize an instance of PromptExecutionMeta to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      {
-        "model_name": @model_name,
-        "latency": @latency,
-        "deployment_release_tag": @deployment_release_tag,
-        "prompt_version_id": @prompt_version_id,
-        "finish_reason": FINISH_REASON_ENUM[@finish_reason] || @finish_reason
-      }.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.model_name&.is_a?(String) != false || raise("Passed value for field obj.model_name is not the expected type, validation failed.")
       obj.latency&.is_a?(Integer) != false || raise("Passed value for field obj.latency is not the expected type, validation failed.")
       obj.deployment_release_tag&.is_a?(String) != false || raise("Passed value for field obj.deployment_release_tag is not the expected type, validation failed.")
       obj.prompt_version_id&.is_a?(String) != false || raise("Passed value for field obj.prompt_version_id is not the expected type, validation failed.")
-      obj.finish_reason&.is_a?(FINISH_REASON_ENUM) != false || raise("Passed value for field obj.finish_reason is not the expected type, validation failed.")
+      obj.finish_reason&.is_a?(Vellum::FinishReasonEnum) != false || raise("Passed value for field obj.finish_reason is not the expected type, validation failed.")
+      obj.usage.nil? || Vellum::MlModelUsage.validate_raw(obj: obj.usage)
+      obj.cost.nil? || Vellum::Price.validate_raw(obj: obj.cost)
     end
   end
-end
+end

data/lib/vellum_ai/types/prompt_node_execution_meta.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+require_relative "ml_model_usage"
+require_relative "price"
+require "ostruct"
+require "json"
+
+module Vellum
+# The subset of the metadata tracked by Vellum during prompt execution that the
+#  request opted into with `expand_meta`.
+  class PromptNodeExecutionMeta
+  # @return [Vellum::MlModelUsage] 
+    attr_reader :usage
+  # @return [Vellum::Price] 
+    attr_reader :cost
+  # @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 usage [Vellum::MlModelUsage] 
+    # @param cost [Vellum::Price] 
+    # @param model_name [String] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::PromptNodeExecutionMeta]
+    def initialize(usage: OMIT, cost: OMIT, model_name: OMIT, additional_properties: nil)
+      @usage = usage if usage != OMIT
+      @cost = cost if cost != OMIT
+      @model_name = model_name if model_name != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "usage": usage, "cost": cost, "model_name": model_name }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of PromptNodeExecutionMeta
+    #
+    # @param json_object [String] 
+    # @return [Vellum::PromptNodeExecutionMeta]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      unless parsed_json["usage"].nil?
+        usage = parsed_json["usage"].to_json
+        usage = Vellum::MlModelUsage.from_json(json_object: usage)
+      else
+        usage = nil
+      end
+      unless parsed_json["cost"].nil?
+        cost = parsed_json["cost"].to_json
+        cost = Vellum::Price.from_json(json_object: cost)
+      else
+        cost = nil
+      end
+      model_name = parsed_json["model_name"]
+      new(
+        usage: usage,
+        cost: cost,
+        model_name: model_name,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of PromptNodeExecutionMeta 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.usage.nil? || Vellum::MlModelUsage.validate_raw(obj: obj.usage)
+      obj.cost.nil? || Vellum::Price.validate_raw(obj: obj.cost)
+      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/prompt_node_result.rb

@@ -1,52 +1,68 @@
 # frozen_string_literal: true
-
 require_relative "prompt_node_result_data"
+require "ostruct"
 require "json"
 
 module Vellum
-  # A Node Result Event emitted from a Prompt Node.
+# A Node Result Event emitted from a Prompt Node.
   class PromptNodeResult
-    attr_reader :data, :additional_properties
+  # @return [String] 
+    attr_reader :type
+  # @return [Vellum::PromptNodeResultData] 
+    attr_reader :data
+  # @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 [PromptNodeResultData]
+    # @param type [String] 
+    # @param data [Vellum::PromptNodeResultData] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [PromptNodeResult]
-    def initialize(data:, additional_properties: nil)
-      # @type [PromptNodeResultData]
+    # @return [Vellum::PromptNodeResult]
+    def initialize(type:, data:, additional_properties: nil)
+      @type = type
       @data = data
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "type": type, "data": data }
     end
-
-    # Deserialize a JSON object to an instance of PromptNodeResult
+# Deserialize a JSON object to an instance of PromptNodeResult
     #
-    # @param json_object [JSON]
-    # @return [PromptNodeResult]
+    # @param json_object [String] 
+    # @return [Vellum::PromptNodeResult]
     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
+      type = parsed_json["type"]
+      unless parsed_json["data"].nil?
         data = parsed_json["data"].to_json
-        data = PromptNodeResultData.from_json(json_object: data)
+        data = Vellum::PromptNodeResultData.from_json(json_object: data)
+      else
+        data = nil
       end
-      new(data: data, additional_properties: struct)
+      new(
+        type: type,
+        data: data,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of PromptNodeResult to a JSON object
+# Serialize an instance of PromptNodeResult to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "data": @data }.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:)
-      PromptNodeResultData.validate_raw(obj: obj.data)
+      obj.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      Vellum::PromptNodeResultData.validate_raw(obj: obj.data)
     end
   end
-end
+end

data/lib/vellum_ai/types/prompt_node_result_data.rb

@@ -1,61 +1,97 @@
 # frozen_string_literal: true
-
+require_relative "prompt_node_execution_meta"
+require "ostruct"
 require "json"
 
 module Vellum
   class PromptNodeResultData
-    attr_reader :output_id, :array_output_id, :text, :delta, :additional_properties
+  # @return [Vellum::PromptNodeExecutionMeta] 
+    attr_reader :execution_meta
+  # @return [String] 
+    attr_reader :output_id
+  # @return [String] 
+    attr_reader :array_output_id
+  # @return [String] 
+    attr_reader :execution_id
+  # @return [String] 
+    attr_reader :text
+  # @return [String] 
+    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 output_id [String]
-    # @param array_output_id [String]
-    # @param text [String]
-    # @param delta [String]
+    # @param execution_meta [Vellum::PromptNodeExecutionMeta] 
+    # @param output_id [String] 
+    # @param array_output_id [String] 
+    # @param execution_id [String] 
+    # @param text [String] 
+    # @param delta [String] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [PromptNodeResultData]
-    def initialize(output_id:, array_output_id: nil, text: nil, delta: nil, additional_properties: nil)
-      # @type [String]
+    # @return [Vellum::PromptNodeResultData]
+    def initialize(execution_meta: OMIT, output_id:, array_output_id: OMIT, execution_id: OMIT, text: OMIT, delta: OMIT, additional_properties: nil)
+      @execution_meta = execution_meta if execution_meta != OMIT
       @output_id = output_id
-      # @type [String]
-      @array_output_id = array_output_id
-      # @type [String]
-      @text = text
-      # @type [String]
-      @delta = delta
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @array_output_id = array_output_id if array_output_id != OMIT
+      @execution_id = execution_id if execution_id != OMIT
+      @text = text if text != OMIT
+      @delta = delta if delta != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "execution_meta": execution_meta, "output_id": output_id, "array_output_id": array_output_id, "execution_id": execution_id, "text": text, "delta": delta }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of PromptNodeResultData
+# Deserialize a JSON object to an instance of PromptNodeResultData
     #
-    # @param json_object [JSON]
-    # @return [PromptNodeResultData]
+    # @param json_object [String] 
+    # @return [Vellum::PromptNodeResultData]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      JSON.parse(json_object)
-      output_id = struct.output_id
-      array_output_id = struct.array_output_id
-      text = struct.text
-      delta = struct.delta
-      new(output_id: output_id, array_output_id: array_output_id, text: text, delta: delta,
-          additional_properties: struct)
+      parsed_json = JSON.parse(json_object)
+      unless parsed_json["execution_meta"].nil?
+        execution_meta = parsed_json["execution_meta"].to_json
+        execution_meta = Vellum::PromptNodeExecutionMeta.from_json(json_object: execution_meta)
+      else
+        execution_meta = nil
+      end
+      output_id = parsed_json["output_id"]
+      array_output_id = parsed_json["array_output_id"]
+      execution_id = parsed_json["execution_id"]
+      text = parsed_json["text"]
+      delta = parsed_json["delta"]
+      new(
+        execution_meta: execution_meta,
+        output_id: output_id,
+        array_output_id: array_output_id,
+        execution_id: execution_id,
+        text: text,
+        delta: delta,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of PromptNodeResultData to a JSON object
+# Serialize an instance of PromptNodeResultData to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "output_id": @output_id, "array_output_id": @array_output_id, "text": @text, "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:)
+      obj.execution_meta.nil? || Vellum::PromptNodeExecutionMeta.validate_raw(obj: obj.execution_meta)
       obj.output_id.is_a?(String) != false || raise("Passed value for field obj.output_id is not the expected type, validation failed.")
       obj.array_output_id&.is_a?(String) != false || raise("Passed value for field obj.array_output_id is not the expected type, validation failed.")
+      obj.execution_id&.is_a?(String) != false || raise("Passed value for field obj.execution_id is not the expected type, validation failed.")
       obj.text&.is_a?(String) != false || raise("Passed value for field obj.text is not the expected type, validation failed.")
       obj.delta&.is_a?(String) != false || raise("Passed value for field obj.delta is not the expected type, validation failed.")
     end
   end
-end
+end