vellum_ai 0.3.4

data/lib/vellum_ai/types/submit_workflow_execution_actual_request.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "workflow_execution_actual_string_request"
+require_relative "workflow_execution_actual_json_request"
+require_relative "workflow_execution_actual_chat_history_request"
+
+module Vellum
+  class SubmitWorkflowExecutionActualRequest
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [SubmitWorkflowExecutionActualRequest]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of SubmitWorkflowExecutionActualRequest
+    #
+    # @param json_object [JSON]
+    # @return [SubmitWorkflowExecutionActualRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.output_type
+               when "STRING"
+                 WorkflowExecutionActualStringRequest.from_json(json_object: json_object)
+               when "JSON"
+                 WorkflowExecutionActualJsonRequest.from_json(json_object: json_object)
+               when "CHAT_HISTORY"
+                 WorkflowExecutionActualChatHistoryRequest.from_json(json_object: json_object)
+               else
+                 WorkflowExecutionActualStringRequest.from_json(json_object: json_object)
+               end
+      new(member: member, discriminant: struct.output_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, output_type: @discriminant }.to_json
+      when "JSON"
+        { **@member.to_json, output_type: @discriminant }.to_json
+      when "CHAT_HISTORY"
+        { **@member.to_json, output_type: @discriminant }.to_json
+      else
+        { "output_type": @discriminant, value: @member }.to_json
+      end
+      @member.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:)
+      case obj.output_type
+      when "STRING"
+        WorkflowExecutionActualStringRequest.validate_raw(obj: obj)
+      when "JSON"
+        WorkflowExecutionActualJsonRequest.validate_raw(obj: obj)
+      when "CHAT_HISTORY"
+        WorkflowExecutionActualChatHistoryRequest.validate_raw(obj: obj)
+      else
+        raise("Passed value matched no type within the union, validation failed.")
+      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 [WorkflowExecutionActualStringRequest]
+    # @return [SubmitWorkflowExecutionActualRequest]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [WorkflowExecutionActualJsonRequest]
+    # @return [SubmitWorkflowExecutionActualRequest]
+    def self.json(member:)
+      new(member: member, discriminant: "JSON")
+    end
+
+    # @param member [WorkflowExecutionActualChatHistoryRequest]
+    # @return [SubmitWorkflowExecutionActualRequest]
+    def self.chat_history(member:)
+      new(member: member, discriminant: "CHAT_HISTORY")
+    end
+  end
+end

data/lib/vellum_ai/types/templating_node_chat_history_result.rb

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "vellum_error"
+require "json"
+
+module Vellum
+  class TemplatingNodeErrorResult
+    attr_reader :id, :value, :additional_properties
+
+    # @param id [String]
+    # @param value [VellumError]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [TemplatingNodeErrorResult]
+    def initialize(id:, value: nil, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [VellumError]
+      @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 TemplatingNodeErrorResult
+    #
+    # @param json_object [JSON]
+    # @return [TemplatingNodeErrorResult]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      if parsed_json["value"].nil?
+        value = nil
+      else
+        value = parsed_json["value"].to_json
+        value = VellumError.from_json(json_object: value)
+      end
+      new(id: id, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of TemplatingNodeErrorResult to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "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.value.nil? || VellumError.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/templating_node_json_result.rb

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

data/lib/vellum_ai/types/templating_node_number_result.rb

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

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

data/lib/vellum_ai/types/templating_node_result_data.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "templating_node_result_output"
+require "json"
+
+module Vellum
+  class TemplatingNodeResultData
+    attr_reader :output, :additional_properties
+
+    # @param output [TemplatingNodeResultOutput]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [TemplatingNodeResultData]
+    def initialize(output:, additional_properties: nil)
+      # @type [TemplatingNodeResultOutput]
+      @output = output
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of TemplatingNodeResultData
+    #
+    # @param json_object [JSON]
+    # @return [TemplatingNodeResultData]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["output"].nil?
+        output = nil
+      else
+        output = parsed_json["output"].to_json
+        output = TemplatingNodeResultOutput.from_json(json_object: output)
+      end
+      new(output: output, additional_properties: struct)
+    end
+
+    # Serialize an instance of TemplatingNodeResultData to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "output": @output }.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:)
+      TemplatingNodeResultOutput.validate_raw(obj: obj.output)
+    end
+  end
+end

data/lib/vellum_ai/types/templating_node_result_output.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "templating_node_string_result"
+require_relative "templating_node_number_result"
+require_relative "templating_node_json_result"
+require_relative "templating_node_chat_history_result"
+require_relative "templating_node_search_results_result"
+require_relative "templating_node_error_result"
+
+module Vellum
+  class TemplatingNodeResultOutput
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [TemplatingNodeResultOutput]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of TemplatingNodeResultOutput
+    #
+    # @param json_object [JSON]
+    # @return [TemplatingNodeResultOutput]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "STRING"
+                 TemplatingNodeStringResult.from_json(json_object: json_object)
+               when "NUMBER"
+                 TemplatingNodeNumberResult.from_json(json_object: json_object)
+               when "JSON"
+                 TemplatingNodeJsonResult.from_json(json_object: json_object)
+               when "CHAT_HISTORY"
+                 TemplatingNodeChatHistoryResult.from_json(json_object: json_object)
+               when "SEARCH_RESULTS"
+                 TemplatingNodeSearchResultsResult.from_json(json_object: json_object)
+               when "ERROR"
+                 TemplatingNodeErrorResult.from_json(json_object: json_object)
+               else
+                 TemplatingNodeStringResult.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 "NUMBER"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "JSON"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "CHAT_HISTORY"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "SEARCH_RESULTS"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "ERROR"
+        { **@member.to_json, type: @discriminant }.to_json
+      else
+        { "type": @discriminant, value: @member }.to_json
+      end
+      @member.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:)
+      case obj.type
+      when "STRING"
+        TemplatingNodeStringResult.validate_raw(obj: obj)
+      when "NUMBER"
+        TemplatingNodeNumberResult.validate_raw(obj: obj)
+      when "JSON"
+        TemplatingNodeJsonResult.validate_raw(obj: obj)
+      when "CHAT_HISTORY"
+        TemplatingNodeChatHistoryResult.validate_raw(obj: obj)
+      when "SEARCH_RESULTS"
+        TemplatingNodeSearchResultsResult.validate_raw(obj: obj)
+      when "ERROR"
+        TemplatingNodeErrorResult.validate_raw(obj: obj)
+      else
+        raise("Passed value matched no type within the union, validation failed.")
+      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 [TemplatingNodeStringResult]
+    # @return [TemplatingNodeResultOutput]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [TemplatingNodeNumberResult]
+    # @return [TemplatingNodeResultOutput]
+    def self.number(member:)
+      new(member: member, discriminant: "NUMBER")
+    end
+
+    # @param member [TemplatingNodeJsonResult]
+    # @return [TemplatingNodeResultOutput]
+    def self.json(member:)
+      new(member: member, discriminant: "JSON")
+    end
+
+    # @param member [TemplatingNodeChatHistoryResult]
+    # @return [TemplatingNodeResultOutput]
+    def self.chat_history(member:)
+      new(member: member, discriminant: "CHAT_HISTORY")
+    end
+
+    # @param member [TemplatingNodeSearchResultsResult]
+    # @return [TemplatingNodeResultOutput]
+    def self.search_results(member:)
+      new(member: member, discriminant: "SEARCH_RESULTS")
+    end
+
+    # @param member [TemplatingNodeErrorResult]
+    # @return [TemplatingNodeResultOutput]
+    def self.error(member:)
+      new(member: member, discriminant: "ERROR")
+    end
+  end
+end

data/lib/vellum_ai/types/templating_node_search_results_result.rb

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

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