vellum_ai 0.3.15 → 0.14.74

data/lib/vellum_ai/types/fulfilled_execute_prompt_event.rb

@@ -1,66 +1,89 @@
 # frozen_string_literal: true
-
 require_relative "prompt_output"
 require_relative "fulfilled_prompt_execution_meta"
+require "ostruct"
 require "json"
 
 module Vellum
-  # The final data event returned indicating that the stream has ended and all final resolved values from the model can be found.
+# The final data event returned indicating that the stream has ended and all final
+#  resolved values from the model can be found.
   class FulfilledExecutePromptEvent
-    attr_reader :outputs, :execution_id, :meta, :additional_properties
+  # @return [String] 
+    attr_reader :state
+  # @return [Array<Vellum::PromptOutput>] 
+    attr_reader :outputs
+  # @return [String] 
+    attr_reader :execution_id
+  # @return [Vellum::FulfilledPromptExecutionMeta] 
+    attr_reader :meta
+  # @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 outputs [Array<PromptOutput>]
-    # @param execution_id [String]
-    # @param meta [FulfilledPromptExecutionMeta]
+    # @param state [String] 
+    # @param outputs [Array<Vellum::PromptOutput>] 
+    # @param execution_id [String] 
+    # @param meta [Vellum::FulfilledPromptExecutionMeta] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [FulfilledExecutePromptEvent]
-    def initialize(outputs:, execution_id:, meta: nil, additional_properties: nil)
-      # @type [Array<PromptOutput>]
+    # @return [Vellum::FulfilledExecutePromptEvent]
+    def initialize(state:, outputs:, execution_id:, meta: OMIT, additional_properties: nil)
+      @state = state
       @outputs = outputs
-      # @type [String]
       @execution_id = execution_id
-      # @type [FulfilledPromptExecutionMeta]
-      @meta = meta
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @meta = meta if meta != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "state": state, "outputs": outputs, "execution_id": execution_id, "meta": meta }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of FulfilledExecutePromptEvent
+# Deserialize a JSON object to an instance of FulfilledExecutePromptEvent
     #
-    # @param json_object [JSON]
-    # @return [FulfilledExecutePromptEvent]
+    # @param json_object [String] 
+    # @return [Vellum::FulfilledExecutePromptEvent]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      outputs = parsed_json["outputs"].map do |v|
-        v = v.to_json
-        PromptOutput.from_json(json_object: v)
-      end
-      execution_id = struct.execution_id
-      if parsed_json["meta"].nil?
-        meta = nil
-      else
+      state = parsed_json["state"]
+      outputs = parsed_json["outputs"]&.map do | item |
+  item = item.to_json
+  Vellum::PromptOutput.from_json(json_object: item)
+end
+      execution_id = parsed_json["execution_id"]
+      unless parsed_json["meta"].nil?
         meta = parsed_json["meta"].to_json
-        meta = FulfilledPromptExecutionMeta.from_json(json_object: meta)
+        meta = Vellum::FulfilledPromptExecutionMeta.from_json(json_object: meta)
+      else
+        meta = nil
       end
-      new(outputs: outputs, execution_id: execution_id, meta: meta, additional_properties: struct)
+      new(
+        state: state,
+        outputs: outputs,
+        execution_id: execution_id,
+        meta: meta,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of FulfilledExecutePromptEvent to a JSON object
+# Serialize an instance of FulfilledExecutePromptEvent to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "outputs": @outputs, "execution_id": @execution_id, "meta": @meta }.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.state.is_a?(String) != false || raise("Passed value for field obj.state is not the expected type, validation failed.")
       obj.outputs.is_a?(Array) != false || raise("Passed value for field obj.outputs 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.meta.nil? || FulfilledPromptExecutionMeta.validate_raw(obj: obj.meta)
+      obj.meta.nil? || Vellum::FulfilledPromptExecutionMeta.validate_raw(obj: obj.meta)
     end
   end
-end
+end

data/lib/vellum_ai/types/fulfilled_execute_prompt_response.rb

@@ -1,71 +1,98 @@
 # frozen_string_literal: true
-
 require_relative "prompt_execution_meta"
 require_relative "prompt_output"
+require "ostruct"
 require "json"
 
 module Vellum
-  # The successful response from the model containing all of the resolved values generated by the prompt.
+# The successful response from the model containing all of the resolved values
+#  generated by the prompt.
   class FulfilledExecutePromptResponse
-    attr_reader :meta, :raw, :execution_id, :outputs, :additional_properties
+  # @return [Vellum::PromptExecutionMeta] 
+    attr_reader :meta
+  # @return [Hash{String => Object}] The subset of the raw response from the model that the request opted into with
+#  `expand_raw`.
+    attr_reader :raw
+  # @return [String] The ID of the execution.
+    attr_reader :execution_id
+  # @return [String] 
+    attr_reader :state
+  # @return [Array<Vellum::PromptOutput>] 
+    attr_reader :outputs
+  # @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 meta [PromptExecutionMeta]
-    # @param raw [Hash{String => String}] The subset of the raw response from the model that the request opted into with `expand_raw`.
+    # @param meta [Vellum::PromptExecutionMeta] 
+    # @param raw [Hash{String => Object}] The subset of the raw response from the model that the request opted into with
+#  `expand_raw`.
     # @param execution_id [String] The ID of the execution.
-    # @param outputs [Array<PromptOutput>]
+    # @param state [String] 
+    # @param outputs [Array<Vellum::PromptOutput>] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [FulfilledExecutePromptResponse]
-    def initialize(execution_id:, outputs:, meta: nil, raw: nil, additional_properties: nil)
-      # @type [PromptExecutionMeta]
-      @meta = meta
-      # @type [Hash{String => String}] The subset of the raw response from the model that the request opted into with `expand_raw`.
-      @raw = raw
-      # @type [String] The ID of the execution.
+    # @return [Vellum::FulfilledExecutePromptResponse]
+    def initialize(meta: OMIT, raw: OMIT, execution_id:, state:, outputs:, additional_properties: nil)
+      @meta = meta if meta != OMIT
+      @raw = raw if raw != OMIT
       @execution_id = execution_id
-      # @type [Array<PromptOutput>]
+      @state = state
       @outputs = outputs
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "meta": meta, "raw": raw, "execution_id": execution_id, "state": state, "outputs": outputs }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of FulfilledExecutePromptResponse
+# Deserialize a JSON object to an instance of FulfilledExecutePromptResponse
     #
-    # @param json_object [JSON]
-    # @return [FulfilledExecutePromptResponse]
+    # @param json_object [String] 
+    # @return [Vellum::FulfilledExecutePromptResponse]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      if parsed_json["meta"].nil?
-        meta = nil
-      else
+      unless parsed_json["meta"].nil?
         meta = parsed_json["meta"].to_json
-        meta = PromptExecutionMeta.from_json(json_object: meta)
-      end
-      raw = struct.raw
-      execution_id = struct.execution_id
-      outputs = parsed_json["outputs"].map do |v|
-        v = v.to_json
-        PromptOutput.from_json(json_object: v)
+        meta = Vellum::PromptExecutionMeta.from_json(json_object: meta)
+      else
+        meta = nil
       end
-      new(meta: meta, raw: raw, execution_id: execution_id, outputs: outputs, additional_properties: struct)
+      raw = parsed_json["raw"]
+      execution_id = parsed_json["execution_id"]
+      state = parsed_json["state"]
+      outputs = parsed_json["outputs"]&.map do | item |
+  item = item.to_json
+  Vellum::PromptOutput.from_json(json_object: item)
+end
+      new(
+        meta: meta,
+        raw: raw,
+        execution_id: execution_id,
+        state: state,
+        outputs: outputs,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of FulfilledExecutePromptResponse to a JSON object
+# Serialize an instance of FulfilledExecutePromptResponse to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "meta": @meta, "raw": @raw, "execution_id": @execution_id, "outputs": @outputs }.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.meta.nil? || PromptExecutionMeta.validate_raw(obj: obj.meta)
+      obj.meta.nil? || Vellum::PromptExecutionMeta.validate_raw(obj: obj.meta)
       obj.raw&.is_a?(Hash) != false || raise("Passed value for field obj.raw 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.state.is_a?(String) != false || raise("Passed value for field obj.state is not the expected type, validation failed.")
       obj.outputs.is_a?(Array) != false || raise("Passed value for field obj.outputs is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/fulfilled_execute_workflow_workflow_result_event.rb

@@ -1,61 +1,88 @@
 # frozen_string_literal: true
-
 require "date"
 require_relative "workflow_output"
+require "ostruct"
 require "json"
 
 module Vellum
-  # The successful response from the Workflow execution containing the produced outputs.
+# The successful response from the Workflow execution containing the produced
+#  outputs.
   class FulfilledExecuteWorkflowWorkflowResultEvent
-    attr_reader :id, :ts, :outputs, :additional_properties
+  # @return [String] 
+    attr_reader :id
+  # @return [String] 
+    attr_reader :state
+  # @return [DateTime] 
+    attr_reader :ts
+  # @return [Array<Vellum::WorkflowOutput>] 
+    attr_reader :outputs
+  # @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 id [String]
-    # @param ts [DateTime]
-    # @param outputs [Array<WorkflowOutput>]
+    # @param id [String] 
+    # @param state [String] 
+    # @param ts [DateTime] 
+    # @param outputs [Array<Vellum::WorkflowOutput>] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [FulfilledExecuteWorkflowWorkflowResultEvent]
-    def initialize(id:, ts:, outputs:, additional_properties: nil)
-      # @type [String]
+    # @return [Vellum::FulfilledExecuteWorkflowWorkflowResultEvent]
+    def initialize(id:, state:, ts:, outputs:, additional_properties: nil)
       @id = id
-      # @type [DateTime]
+      @state = state
       @ts = ts
-      # @type [Array<WorkflowOutput>]
       @outputs = outputs
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
+      @_field_set = { "id": id, "state": state, "ts": ts, "outputs": outputs }
     end
-
-    # Deserialize a JSON object to an instance of FulfilledExecuteWorkflowWorkflowResultEvent
+# Deserialize a JSON object to an instance of
+#  FulfilledExecuteWorkflowWorkflowResultEvent
     #
-    # @param json_object [JSON]
-    # @return [FulfilledExecuteWorkflowWorkflowResultEvent]
+    # @param json_object [String] 
+    # @return [Vellum::FulfilledExecuteWorkflowWorkflowResultEvent]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      id = struct.id
-      ts = DateTime.parse(parsed_json["ts"])
-      outputs = parsed_json["outputs"].map do |v|
-        v = v.to_json
-        WorkflowOutput.from_json(json_object: v)
-      end
-      new(id: id, ts: ts, outputs: outputs, additional_properties: struct)
+      id = parsed_json["id"]
+      state = parsed_json["state"]
+      ts = unless parsed_json["ts"].nil?
+  DateTime.parse(parsed_json["ts"])
+else
+  nil
+end
+      outputs = parsed_json["outputs"]&.map do | item |
+  item = item.to_json
+  Vellum::WorkflowOutput.from_json(json_object: item)
+end
+      new(
+        id: id,
+        state: state,
+        ts: ts,
+        outputs: outputs,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of FulfilledExecuteWorkflowWorkflowResultEvent to a JSON object
+# Serialize an instance of FulfilledExecuteWorkflowWorkflowResultEvent to a JSON
+#  object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "id": @id, "ts": @ts, "outputs": @outputs }.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.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.state.is_a?(String) != false || raise("Passed value for field obj.state is not the expected type, validation failed.")
       obj.ts.is_a?(DateTime) != false || raise("Passed value for field obj.ts is not the expected type, validation failed.")
       obj.outputs.is_a?(Array) != false || raise("Passed value for field obj.outputs is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/fulfilled_prompt_execution_meta.rb

@@ -1,52 +1,92 @@
 # 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 FulfilledPromptExecutionMeta
-    attr_reader :latency, :finish_reason, :additional_properties
+  # @return [Integer] 
+    attr_reader :latency
+  # @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 latency [Integer]
-    # @param finish_reason [FINISH_REASON_ENUM]
+    # @param latency [Integer] 
+    # @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 [FulfilledPromptExecutionMeta]
-    def initialize(latency: nil, finish_reason: nil, additional_properties: nil)
-      # @type [Integer]
-      @latency = latency
-      # @type [FINISH_REASON_ENUM]
-      @finish_reason = finish_reason
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::FulfilledPromptExecutionMeta]
+    def initialize(latency: OMIT, finish_reason: OMIT, usage: OMIT, cost: OMIT, additional_properties: nil)
+      @latency = latency if latency != 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 = { "latency": latency, "finish_reason": finish_reason, "usage": usage, "cost": cost }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of FulfilledPromptExecutionMeta
+# Deserialize a JSON object to an instance of FulfilledPromptExecutionMeta
     #
-    # @param json_object [JSON]
-    # @return [FulfilledPromptExecutionMeta]
+    # @param json_object [String] 
+    # @return [Vellum::FulfilledPromptExecutionMeta]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      latency = struct.latency
-      finish_reason = FINISH_REASON_ENUM.key(parsed_json["finish_reason"]) || parsed_json["finish_reason"]
-      new(latency: latency, finish_reason: finish_reason, additional_properties: struct)
+      latency = parsed_json["latency"]
+      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(
+        latency: latency,
+        finish_reason: finish_reason,
+        usage: usage,
+        cost: cost,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of FulfilledPromptExecutionMeta to a JSON object
+# Serialize an instance of FulfilledPromptExecutionMeta to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "latency": @latency, "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.latency&.is_a?(Integer) != false || raise("Passed value for field obj.latency 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