vellum_ai 0.3.7 → 0.3.9

data/lib/vellum_ai/types/node_output_compiled_value.rb

@@ -7,6 +7,8 @@ require_relative "node_output_compiled_json_value"
 require_relative "node_output_compiled_chat_history_value"
 require_relative "node_output_compiled_search_results_value"
 require_relative "node_output_compiled_error_value"
+require_relative "node_output_compiled_array_value"
+require_relative "node_output_compiled_function_value"
 
 module Vellum
   class NodeOutputCompiledValue
@@ -43,6 +45,10 @@ module Vellum
                  NodeOutputCompiledSearchResultsValue.from_json(json_object: json_object)
                when "ERROR"
                  NodeOutputCompiledErrorValue.from_json(json_object: json_object)
+               when "ARRAY"
+                 NodeOutputCompiledArrayValue.from_json(json_object: json_object)
+               when "FUNCTION_CALL"
+                 NodeOutputCompiledFunctionValue.from_json(json_object: json_object)
                else
                  NodeOutputCompiledStringValue.from_json(json_object: json_object)
                end
@@ -66,6 +72,10 @@ module Vellum
         { **@member.to_json, type: @discriminant }.to_json
       when "ERROR"
         { **@member.to_json, type: @discriminant }.to_json
+      when "ARRAY"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "FUNCTION_CALL"
+        { **@member.to_json, type: @discriminant }.to_json
       else
         { "type": @discriminant, value: @member }.to_json
       end
@@ -90,6 +100,10 @@ module Vellum
         NodeOutputCompiledSearchResultsValue.validate_raw(obj: obj)
       when "ERROR"
         NodeOutputCompiledErrorValue.validate_raw(obj: obj)
+      when "ARRAY"
+        NodeOutputCompiledArrayValue.validate_raw(obj: obj)
+      when "FUNCTION_CALL"
+        NodeOutputCompiledFunctionValue.validate_raw(obj: obj)
       else
         raise("Passed value matched no type within the union, validation failed.")
       end
@@ -138,5 +152,17 @@ module Vellum
     def self.error(member:)
       new(member: member, discriminant: "ERROR")
     end
+
+    # @param member [NodeOutputCompiledArrayValue]
+    # @return [NodeOutputCompiledValue]
+    def self.array(member:)
+      new(member: member, discriminant: "ARRAY")
+    end
+
+    # @param member [NodeOutputCompiledFunctionValue]
+    # @return [NodeOutputCompiledValue]
+    def self.function_call(member:)
+      new(member: member, discriminant: "FUNCTION_CALL")
+    end
   end
 end

data/lib/vellum_ai/types/number_variable_value.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  class NumberVariableValue
+    attr_reader :value, :additional_properties
+
+    # @param value [Float]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [NumberVariableValue]
+    def initialize(value: nil, additional_properties: nil)
+      # @type [Float]
+      @value = value
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of NumberVariableValue
+    #
+    # @param json_object [JSON]
+    # @return [NumberVariableValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      value = struct.value
+      new(value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of NumberVariableValue to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "value": @value }.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.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/prompt_node_result_data.rb

@@ -4,17 +4,20 @@ require "json"
 
 module Vellum
   class PromptNodeResultData
-    attr_reader :output_id, :text, :delta, :additional_properties
+    attr_reader :output_id, :array_output_id, :text, :delta, :additional_properties
 
     # @param output_id [String]
+    # @param array_output_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:, text: nil, delta: nil, additional_properties: nil)
+    def initialize(output_id:, array_output_id: nil, text: nil, delta: nil, additional_properties: nil)
       # @type [String]
       @output_id = output_id
       # @type [String]
+      @array_output_id = array_output_id
+      # @type [String]
       @text = text
       # @type [String]
       @delta = delta
@@ -30,16 +33,18 @@ module Vellum
       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, text: text, delta: delta, additional_properties: struct)
+      new(output_id: output_id, array_output_id: array_output_id, text: text, delta: delta,
+          additional_properties: struct)
     end
 
     # Serialize an instance of PromptNodeResultData to a JSON object
     #
     # @return [JSON]
     def to_json(*_args)
-      { "output_id": @output_id, "text": @text, "delta": @delta }.to_json
+      { "output_id": @output_id, "array_output_id": @array_output_id, "text": @text, "delta": @delta }.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.
@@ -48,6 +53,7 @@ module Vellum
     # @return [Void]
     def self.validate_raw(obj:)
       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.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

data/lib/vellum_ai/types/search_results_variable_value.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "search_result"
+require "json"
+
+module Vellum
+  class SearchResultsVariableValue
+    attr_reader :value, :additional_properties
+
+    # @param value [Array<SearchResult>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [SearchResultsVariableValue]
+    def initialize(value: nil, additional_properties: nil)
+      # @type [Array<SearchResult>]
+      @value = value
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of SearchResultsVariableValue
+    #
+    # @param json_object [JSON]
+    # @return [SearchResultsVariableValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      value = parsed_json["value"].map do |v|
+        v = v.to_json
+        SearchResult.from_json(json_object: v)
+      end
+      new(value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of SearchResultsVariableValue to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "value": @value }.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.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/subworkflow_enum.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Vellum
+  SUBWORKFLOW_ENUM = String
+end

data/lib/vellum_ai/types/subworkflow_node_result.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  # A Node Result Event emitted from a Subworkflow Node.
+  class SubworkflowNodeResult
+    attr_reader :additional_properties
+
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [SubworkflowNodeResult]
+    def initialize(additional_properties: nil)
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of SubworkflowNodeResult
+    #
+    # @param json_object [JSON]
+    # @return [SubworkflowNodeResult]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      new(additional_properties: struct)
+    end
+
+    # Serialize an instance of SubworkflowNodeResult to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {}.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:); end
+  end
+end

data/lib/vellum_ai/types/terminal_node_array_result.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "array_variable_value_item"
+require "json"
+
+module Vellum
+  class TerminalNodeArrayResult
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String]
+    # @param name [String] The unique name given to the terminal node that produced this output.
+    # @param value [Array<ArrayVariableValueItem>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [TerminalNodeArrayResult]
+    def initialize(name:, id: nil, value: nil, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String] The unique name given to the terminal node that produced this output.
+      @name = name
+      # @type [Array<ArrayVariableValueItem>]
+      @value = value
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of TerminalNodeArrayResult
+    #
+    # @param json_object [JSON]
+    # @return [TerminalNodeArrayResult]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      value = parsed_json["value"].map do |v|
+        v = v.to_json
+        ArrayVariableValueItem.from_json(json_object: v)
+      end
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of TerminalNodeArrayResult to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "name": @name, "value": @value }.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.id&.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name 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/terminal_node_function_call_result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "function_call"
+require "json"
+
+module Vellum
+  class TerminalNodeFunctionCallResult
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String]
+    # @param name [String] The unique name given to the terminal node that produced this output.
+    # @param value [FunctionCall]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [TerminalNodeFunctionCallResult]
+    def initialize(name:, id: nil, value: nil, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String] The unique name given to the terminal node that produced this output.
+      @name = name
+      # @type [FunctionCall]
+      @value = value
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of TerminalNodeFunctionCallResult
+    #
+    # @param json_object [JSON]
+    # @return [TerminalNodeFunctionCallResult]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      if parsed_json["value"].nil?
+        value = nil
+      else
+        value = parsed_json["value"].to_json
+        value = FunctionCall.from_json(json_object: value)
+      end
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of TerminalNodeFunctionCallResult to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "name": @name, "value": @value }.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.id&.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.value.nil? || FunctionCall.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/terminal_node_result_output.rb

@@ -6,6 +6,8 @@ require_relative "terminal_node_number_result"
 require_relative "terminal_node_json_result"
 require_relative "terminal_node_chat_history_result"
 require_relative "terminal_node_search_results_result"
+require_relative "terminal_node_array_result"
+require_relative "terminal_node_function_call_result"
 require_relative "terminal_node_error_result"
 
 module Vellum
@@ -41,6 +43,10 @@ module Vellum
                  TerminalNodeChatHistoryResult.from_json(json_object: json_object)
                when "SEARCH_RESULTS"
                  TerminalNodeSearchResultsResult.from_json(json_object: json_object)
+               when "ARRAY"
+                 TerminalNodeArrayResult.from_json(json_object: json_object)
+               when "FUNCTION_CALL"
+                 TerminalNodeFunctionCallResult.from_json(json_object: json_object)
                when "ERROR"
                  TerminalNodeErrorResult.from_json(json_object: json_object)
                else
@@ -64,6 +70,10 @@ module Vellum
         { **@member.to_json, type: @discriminant }.to_json
       when "SEARCH_RESULTS"
         { **@member.to_json, type: @discriminant }.to_json
+      when "ARRAY"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "FUNCTION_CALL"
+        { **@member.to_json, type: @discriminant }.to_json
       when "ERROR"
         { **@member.to_json, type: @discriminant }.to_json
       else
@@ -88,6 +98,10 @@ module Vellum
         TerminalNodeChatHistoryResult.validate_raw(obj: obj)
       when "SEARCH_RESULTS"
         TerminalNodeSearchResultsResult.validate_raw(obj: obj)
+      when "ARRAY"
+        TerminalNodeArrayResult.validate_raw(obj: obj)
+      when "FUNCTION_CALL"
+        TerminalNodeFunctionCallResult.validate_raw(obj: obj)
       when "ERROR"
         TerminalNodeErrorResult.validate_raw(obj: obj)
       else
@@ -133,6 +147,18 @@ module Vellum
       new(member: member, discriminant: "SEARCH_RESULTS")
     end
 
+    # @param member [TerminalNodeArrayResult]
+    # @return [TerminalNodeResultOutput]
+    def self.array(member:)
+      new(member: member, discriminant: "ARRAY")
+    end
+
+    # @param member [TerminalNodeFunctionCallResult]
+    # @return [TerminalNodeResultOutput]
+    def self.function_call(member:)
+      new(member: member, discriminant: "FUNCTION_CALL")
+    end
+
     # @param member [TerminalNodeErrorResult]
     # @return [TerminalNodeResultOutput]
     def self.error(member:)

data/lib/vellum_ai/types/vellum_error_code_enum.rb

@@ -5,6 +5,7 @@ module Vellum
   VELLUM_ERROR_CODE_ENUM = {
     invalid_request: "INVALID_REQUEST",
     provider_error: "PROVIDER_ERROR",
-    internal_server_error: "INTERNAL_SERVER_ERROR"
+    internal_server_error: "INTERNAL_SERVER_ERROR",
+    user_defined_error: "USER_DEFINED_ERROR"
   }.freeze
 end

data/lib/vellum_ai/types/workflow_deployment_read.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "entity_status"
+require_relative "environment_enum"
+require "date"
+require_relative "vellum_variable"
+require "json"
+
+module Vellum
+  class WorkflowDeploymentRead
+    attr_reader :id, :name, :label, :status, :environment, :created, :last_deployed_on, :input_variables,
+                :output_variables, :additional_properties
+
+    # @param id [String]
+    # @param name [String] A name that uniquely identifies this workflow deployment within its workspace
+    # @param label [String] A human-readable label for the workflow deployment
+    # @param status [ENTITY_STATUS] The current status of the workflow deployment
+    #   - `ACTIVE` - Active
+    #   - `ARCHIVED` - Archived
+    # @param environment [ENVIRONMENT_ENUM] The environment this workflow deployment is used in
+    #   - `DEVELOPMENT` - Development
+    #   - `STAGING` - Staging
+    #   - `PRODUCTION` - Production
+    # @param created [DateTime]
+    # @param last_deployed_on [DateTime]
+    # @param input_variables [Array<VellumVariable>] The input variables this Workflow Deployment expects to receive values for when it is executed.
+    # @param output_variables [Array<VellumVariable>] The output variables this Workflow Deployment produces values for when it's executed.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [WorkflowDeploymentRead]
+    def initialize(id:, name:, label:, created:, last_deployed_on:, input_variables:, output_variables:, status: nil,
+                   environment: nil, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String] A name that uniquely identifies this workflow deployment within its workspace
+      @name = name
+      # @type [String] A human-readable label for the workflow deployment
+      @label = label
+      # @type [ENTITY_STATUS] The current status of the workflow deployment
+      #   - `ACTIVE` - Active
+      #   - `ARCHIVED` - Archived
+      @status = status
+      # @type [ENVIRONMENT_ENUM] The environment this workflow deployment is used in
+      #   - `DEVELOPMENT` - Development
+      #   - `STAGING` - Staging
+      #   - `PRODUCTION` - Production
+      @environment = environment
+      # @type [DateTime]
+      @created = created
+      # @type [DateTime]
+      @last_deployed_on = last_deployed_on
+      # @type [Array<VellumVariable>] The input variables this Workflow Deployment expects to receive values for when it is executed.
+      @input_variables = input_variables
+      # @type [Array<VellumVariable>] The output variables this Workflow Deployment produces values for when it's executed.
+      @output_variables = output_variables
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of WorkflowDeploymentRead
+    #
+    # @param json_object [JSON]
+    # @return [WorkflowDeploymentRead]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      label = struct.label
+      status = ENTITY_STATUS.key(parsed_json["status"]) || parsed_json["status"]
+      environment = ENVIRONMENT_ENUM.key(parsed_json["environment"]) || parsed_json["environment"]
+      created = DateTime.parse(parsed_json["created"])
+      last_deployed_on = DateTime.parse(parsed_json["last_deployed_on"])
+      input_variables = parsed_json["input_variables"].map do |v|
+        v = v.to_json
+        VellumVariable.from_json(json_object: v)
+      end
+      output_variables = parsed_json["output_variables"].map do |v|
+        v = v.to_json
+        VellumVariable.from_json(json_object: v)
+      end
+      new(id: id, name: name, label: label, status: status, environment: environment, created: created,
+          last_deployed_on: last_deployed_on, input_variables: input_variables, output_variables: output_variables, additional_properties: struct)
+    end
+
+    # Serialize an instance of WorkflowDeploymentRead to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "id": @id,
+        "name": @name,
+        "label": @label,
+        "status": ENTITY_STATUS[@status] || @status,
+        "environment": ENVIRONMENT_ENUM[@environment] || @environment,
+        "created": @created,
+        "last_deployed_on": @last_deployed_on,
+        "input_variables": @input_variables,
+        "output_variables": @output_variables
+      }.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.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.label.is_a?(String) != false || raise("Passed value for field obj.label is not the expected type, validation failed.")
+      obj.status&.is_a?(ENTITY_STATUS) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
+      obj.environment&.is_a?(ENVIRONMENT_ENUM) != false || raise("Passed value for field obj.environment is not the expected type, validation failed.")
+      obj.created.is_a?(DateTime) != false || raise("Passed value for field obj.created is not the expected type, validation failed.")
+      obj.last_deployed_on.is_a?(DateTime) != false || raise("Passed value for field obj.last_deployed_on 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.")
+      obj.output_variables.is_a?(Array) != false || raise("Passed value for field obj.output_variables is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/workflow_execution_event_error_code.rb

@@ -8,6 +8,7 @@ module Vellum
     internal_server_error: "INTERNAL_SERVER_ERROR",
     node_execution: "NODE_EXECUTION",
     llm_provider: "LLM_PROVIDER",
-    invalid_template: "INVALID_TEMPLATE"
+    invalid_template: "INVALID_TEMPLATE",
+    user_defined_error: "USER_DEFINED_ERROR"
   }.freeze
 end

data/lib/vellum_ai/types/workflow_node_result_data.rb

@@ -8,6 +8,7 @@ require_relative "code_execution_node_result"
 require_relative "conditional_node_result"
 require_relative "api_node_result"
 require_relative "terminal_node_result"
+require_relative "subworkflow_node_result"
 
 module Vellum
   class WorkflowNodeResultData
@@ -46,6 +47,8 @@ module Vellum
                  ApiNodeResult.from_json(json_object: json_object)
                when "TERMINAL"
                  TerminalNodeResult.from_json(json_object: json_object)
+               when "SUBWORKFLOW"
+                 SubworkflowNodeResult.from_json(json_object: json_object)
                else
                  PromptNodeResult.from_json(json_object: json_object)
                end
@@ -71,6 +74,8 @@ module Vellum
         { **@member.to_json, type: @discriminant }.to_json
       when "TERMINAL"
         { **@member.to_json, type: @discriminant }.to_json
+      when "SUBWORKFLOW"
+        { **@member.to_json, type: @discriminant }.to_json
       else
         { "type": @discriminant, value: @member }.to_json
       end
@@ -97,6 +102,8 @@ module Vellum
         ApiNodeResult.validate_raw(obj: obj)
       when "TERMINAL"
         TerminalNodeResult.validate_raw(obj: obj)
+      when "SUBWORKFLOW"
+        SubworkflowNodeResult.validate_raw(obj: obj)
       else
         raise("Passed value matched no type within the union, validation failed.")
       end
@@ -151,5 +158,11 @@ module Vellum
     def self.terminal(member:)
       new(member: member, discriminant: "TERMINAL")
     end
+
+    # @param member [SubworkflowNodeResult]
+    # @return [WorkflowNodeResultData]
+    def self.subworkflow(member:)
+      new(member: member, discriminant: "SUBWORKFLOW")
+    end
   end
 end

data/lib/vellum_ai/types/workflow_output.rb

@@ -6,6 +6,7 @@ require_relative "workflow_output_number"
 require_relative "workflow_output_json"
 require_relative "workflow_output_chat_history"
 require_relative "workflow_output_search_results"
+require_relative "workflow_output_array"
 require_relative "workflow_output_error"
 require_relative "workflow_output_function_call"
 require_relative "workflow_output_image"
@@ -43,6 +44,8 @@ module Vellum
                  WorkflowOutputChatHistory.from_json(json_object: json_object)
                when "SEARCH_RESULTS"
                  WorkflowOutputSearchResults.from_json(json_object: json_object)
+               when "ARRAY"
+                 WorkflowOutputArray.from_json(json_object: json_object)
                when "ERROR"
                  WorkflowOutputError.from_json(json_object: json_object)
                when "FUNCTION_CALL"
@@ -70,6 +73,8 @@ module Vellum
         { **@member.to_json, type: @discriminant }.to_json
       when "SEARCH_RESULTS"
         { **@member.to_json, type: @discriminant }.to_json
+      when "ARRAY"
+        { **@member.to_json, type: @discriminant }.to_json
       when "ERROR"
         { **@member.to_json, type: @discriminant }.to_json
       when "FUNCTION_CALL"
@@ -98,6 +103,8 @@ module Vellum
         WorkflowOutputChatHistory.validate_raw(obj: obj)
       when "SEARCH_RESULTS"
         WorkflowOutputSearchResults.validate_raw(obj: obj)
+      when "ARRAY"
+        WorkflowOutputArray.validate_raw(obj: obj)
       when "ERROR"
         WorkflowOutputError.validate_raw(obj: obj)
       when "FUNCTION_CALL"
@@ -147,6 +154,12 @@ module Vellum
       new(member: member, discriminant: "SEARCH_RESULTS")
     end
 
+    # @param member [WorkflowOutputArray]
+    # @return [WorkflowOutput]
+    def self.array(member:)
+      new(member: member, discriminant: "ARRAY")
+    end
+
     # @param member [WorkflowOutputError]
     # @return [WorkflowOutput]
     def self.error(member:)