vellum_ai 0.3.15 → 0.14.74

data/lib/vellum_ai/types/workflow_node_result_data.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require "json"
 require_relative "prompt_node_result"
 require_relative "search_node_result"
@@ -8,161 +7,196 @@ require_relative "code_execution_node_result"
 require_relative "conditional_node_result"
 require_relative "api_node_result"
 require_relative "terminal_node_result"
+require_relative "merge_node_result"
 require_relative "subworkflow_node_result"
+require_relative "metric_node_result"
+require_relative "map_node_result"
 
 module Vellum
   class WorkflowNodeResultData
-    attr_reader :member, :discriminant
 
-    private_class_method :new
-    alias kind_of? is_a?
-    # @param member [Object]
-    # @param discriminant [String]
-    # @return [WorkflowNodeResultData]
-    def initialize(member:, discriminant:)
-      # @type [Object]
-      @member = member
-      # @type [String]
-      @discriminant = discriminant
-    end
 
-    # Deserialize a JSON object to an instance of WorkflowNodeResultData
+# Deserialize a JSON object to an instance of WorkflowNodeResultData
     #
-    # @param json_object [JSON]
-    # @return [WorkflowNodeResultData]
+    # @param json_object [String] 
+    # @return [Vellum::WorkflowNodeResultData]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      member = case struct.type
-               when "PROMPT"
-                 PromptNodeResult.from_json(json_object: json_object)
-               when "SEARCH"
-                 SearchNodeResult.from_json(json_object: json_object)
-               when "TEMPLATING"
-                 TemplatingNodeResult.from_json(json_object: json_object)
-               when "CODE_EXECUTION"
-                 CodeExecutionNodeResult.from_json(json_object: json_object)
-               when "CONDITIONAL"
-                 ConditionalNodeResult.from_json(json_object: json_object)
-               when "API"
-                 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
-      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 "PROMPT"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "SEARCH"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "TEMPLATING"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "CODE_EXECUTION"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "CONDITIONAL"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "API"
-        { **@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
-      @member.to_json
+      begin
+        Vellum::PromptNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::PromptNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::SearchNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::SearchNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TemplatingNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TemplatingNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::CodeExecutionNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::CodeExecutionNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::ConditionalNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::ConditionalNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::ApiNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::ApiNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TerminalNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TerminalNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::MergeNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::MergeNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::SubworkflowNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::SubworkflowNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::MetricNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::MetricNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::MapNodeResult.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::MapNodeResult.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+ return struct
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
-      case obj.type
-      when "PROMPT"
-        PromptNodeResult.validate_raw(obj: obj)
-      when "SEARCH"
-        SearchNodeResult.validate_raw(obj: obj)
-      when "TEMPLATING"
-        TemplatingNodeResult.validate_raw(obj: obj)
-      when "CODE_EXECUTION"
-        CodeExecutionNodeResult.validate_raw(obj: obj)
-      when "CONDITIONAL"
-        ConditionalNodeResult.validate_raw(obj: obj)
-      when "API"
-        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.")
+      begin
+        return Vellum::PromptNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
       end
-    end
-
-    # For Union Types, is_a? functionality is delegated to the wrapped member.
-    #
-    # @param obj [Object]
-    # @return [Boolean]
-    def is_a?(obj)
-      @member.is_a?(obj)
-    end
-
-    # @param member [PromptNodeResult]
-    # @return [WorkflowNodeResultData]
-    def self.prompt(member:)
-      new(member: member, discriminant: "PROMPT")
-    end
-
-    # @param member [SearchNodeResult]
-    # @return [WorkflowNodeResultData]
-    def self.search(member:)
-      new(member: member, discriminant: "SEARCH")
-    end
-
-    # @param member [TemplatingNodeResult]
-    # @return [WorkflowNodeResultData]
-    def self.templating(member:)
-      new(member: member, discriminant: "TEMPLATING")
-    end
-
-    # @param member [CodeExecutionNodeResult]
-    # @return [WorkflowNodeResultData]
-    def self.code_execution(member:)
-      new(member: member, discriminant: "CODE_EXECUTION")
-    end
-
-    # @param member [ConditionalNodeResult]
-    # @return [WorkflowNodeResultData]
-    def self.conditional(member:)
-      new(member: member, discriminant: "CONDITIONAL")
-    end
-
-    # @param member [ApiNodeResult]
-    # @return [WorkflowNodeResultData]
-    def self.api(member:)
-      new(member: member, discriminant: "API")
-    end
-
-    # @param member [TerminalNodeResult]
-    # @return [WorkflowNodeResultData]
-    def self.terminal(member:)
-      new(member: member, discriminant: "TERMINAL")
-    end
-
-    # @param member [SubworkflowNodeResult]
-    # @return [WorkflowNodeResultData]
-    def self.subworkflow(member:)
-      new(member: member, discriminant: "SUBWORKFLOW")
+      begin
+        return Vellum::SearchNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::TemplatingNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::CodeExecutionNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::ConditionalNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::ApiNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::TerminalNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::MergeNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::SubworkflowNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::MetricNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::MapNodeResult.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      raise("Passed value matched no type within the union, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/workflow_node_result_event.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require "json"
 require_relative "initiated_workflow_node_result_event"
 require_relative "streaming_workflow_node_result_event"
@@ -8,109 +7,84 @@ require_relative "rejected_workflow_node_result_event"
 
 module Vellum
   class WorkflowNodeResultEvent
-    attr_reader :member, :discriminant
 
-    private_class_method :new
-    alias kind_of? is_a?
-    # @param member [Object]
-    # @param discriminant [String]
-    # @return [WorkflowNodeResultEvent]
-    def initialize(member:, discriminant:)
-      # @type [Object]
-      @member = member
-      # @type [String]
-      @discriminant = discriminant
-    end
 
-    # Deserialize a JSON object to an instance of WorkflowNodeResultEvent
+# Deserialize a JSON object to an instance of WorkflowNodeResultEvent
     #
-    # @param json_object [JSON]
-    # @return [WorkflowNodeResultEvent]
+    # @param json_object [String] 
+    # @return [Vellum::WorkflowNodeResultEvent]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      member = case struct.state
-               when "INITIATED"
-                 InitiatedWorkflowNodeResultEvent.from_json(json_object: json_object)
-               when "STREAMING"
-                 StreamingWorkflowNodeResultEvent.from_json(json_object: json_object)
-               when "FULFILLED"
-                 FulfilledWorkflowNodeResultEvent.from_json(json_object: json_object)
-               when "REJECTED"
-                 RejectedWorkflowNodeResultEvent.from_json(json_object: json_object)
-               else
-                 InitiatedWorkflowNodeResultEvent.from_json(json_object: json_object)
-               end
-      new(member: member, discriminant: struct.state)
-    end
-
-    # For Union Types, to_json functionality is delegated to the wrapped member.
-    #
-    # @return [JSON]
-    def to_json(*_args)
-      case @discriminant
-      when "INITIATED"
-        { **@member.to_json, state: @discriminant }.to_json
-      when "STREAMING"
-        { **@member.to_json, state: @discriminant }.to_json
-      when "FULFILLED"
-        { **@member.to_json, state: @discriminant }.to_json
-      when "REJECTED"
-        { **@member.to_json, state: @discriminant }.to_json
-      else
-        { "state": @discriminant, value: @member }.to_json
+      begin
+        Vellum::InitiatedWorkflowNodeResultEvent.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::InitiatedWorkflowNodeResultEvent.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::StreamingWorkflowNodeResultEvent.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::StreamingWorkflowNodeResultEvent.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::FulfilledWorkflowNodeResultEvent.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::FulfilledWorkflowNodeResultEvent.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
       end
-      @member.to_json
+      begin
+        Vellum::RejectedWorkflowNodeResultEvent.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::RejectedWorkflowNodeResultEvent.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+ return struct
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
-      case obj.state
-      when "INITIATED"
-        InitiatedWorkflowNodeResultEvent.validate_raw(obj: obj)
-      when "STREAMING"
-        StreamingWorkflowNodeResultEvent.validate_raw(obj: obj)
-      when "FULFILLED"
-        FulfilledWorkflowNodeResultEvent.validate_raw(obj: obj)
-      when "REJECTED"
-        RejectedWorkflowNodeResultEvent.validate_raw(obj: obj)
-      else
-        raise("Passed value matched no type within the union, validation failed.")
+      begin
+        return Vellum::InitiatedWorkflowNodeResultEvent.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
       end
-    end
-
-    # For Union Types, is_a? functionality is delegated to the wrapped member.
-    #
-    # @param obj [Object]
-    # @return [Boolean]
-    def is_a?(obj)
-      @member.is_a?(obj)
-    end
-
-    # @param member [InitiatedWorkflowNodeResultEvent]
-    # @return [WorkflowNodeResultEvent]
-    def self.initiated(member:)
-      new(member: member, discriminant: "INITIATED")
-    end
-
-    # @param member [StreamingWorkflowNodeResultEvent]
-    # @return [WorkflowNodeResultEvent]
-    def self.streaming(member:)
-      new(member: member, discriminant: "STREAMING")
-    end
-
-    # @param member [FulfilledWorkflowNodeResultEvent]
-    # @return [WorkflowNodeResultEvent]
-    def self.fulfilled(member:)
-      new(member: member, discriminant: "FULFILLED")
-    end
-
-    # @param member [RejectedWorkflowNodeResultEvent]
-    # @return [WorkflowNodeResultEvent]
-    def self.rejected(member:)
-      new(member: member, discriminant: "REJECTED")
+      begin
+        return Vellum::StreamingWorkflowNodeResultEvent.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::FulfilledWorkflowNodeResultEvent.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::RejectedWorkflowNodeResultEvent.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      raise("Passed value matched no type within the union, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/workflow_node_result_event_state.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
 module Vellum
-  # @type [WORKFLOW_NODE_RESULT_EVENT_STATE]
-  WORKFLOW_NODE_RESULT_EVENT_STATE = {
-    initiated: "INITIATED",
-    streaming: "STREAMING",
-    fulfilled: "FULFILLED",
-    rejected: "REJECTED"
-  }.freeze
-end
+# * `INITIATED` - INITIATED
+#  * `STREAMING` - STREAMING
+#  * `FULFILLED` - FULFILLED
+#  * `REJECTED` - REJECTED
+  class WorkflowNodeResultEventState
+
+    INITIATED = "INITIATED"
+    STREAMING = "STREAMING"
+    FULFILLED = "FULFILLED"
+    REJECTED = "REJECTED"
+
+  end
+end