vellum_ai 0.3.10 → 0.3.12

data/lib/vellum_ai/types/execution_json_vellum_value.rb

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

data/lib/vellum_ai/types/execution_number_vellum_value.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  class ExecutionNumberVellumValue
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String] The variable's uniquely identifying internal id.
+    # @param name [String]
+    # @param value [Float]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ExecutionNumberVellumValue]
+    def initialize(id:, name:, value: nil, additional_properties: nil)
+      # @type [String] The variable's uniquely identifying internal id.
+      @id = id
+      # @type [String]
+      @name = name
+      # @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 ExecutionNumberVellumValue
+    #
+    # @param json_object [JSON]
+    # @return [ExecutionNumberVellumValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      value = struct.value
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ExecutionNumberVellumValue 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?(Float) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/execution_search_results_vellum_value.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "search_result"
+require "json"
+
+module Vellum
+  class ExecutionSearchResultsVellumValue
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String] The variable's uniquely identifying internal id.
+    # @param name [String]
+    # @param value [Array<SearchResult>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ExecutionSearchResultsVellumValue]
+    def initialize(id:, name:, value: nil, additional_properties: nil)
+      # @type [String] The variable's uniquely identifying internal id.
+      @id = id
+      # @type [String]
+      @name = name
+      # @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 ExecutionSearchResultsVellumValue
+    #
+    # @param json_object [JSON]
+    # @return [ExecutionSearchResultsVellumValue]
+    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
+        SearchResult.from_json(json_object: v)
+      end
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ExecutionSearchResultsVellumValue 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/execution_string_vellum_value.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  class ExecutionStringVellumValue
+    attr_reader :id, :name, :value, :additional_properties
+
+    # @param id [String] The variable's uniquely identifying internal id.
+    # @param name [String]
+    # @param value [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ExecutionStringVellumValue]
+    def initialize(id:, name:, value: nil, additional_properties: nil)
+      # @type [String] The variable's uniquely identifying internal id.
+      @id = id
+      # @type [String]
+      @name = name
+      # @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 ExecutionStringVellumValue
+    #
+    # @param json_object [JSON]
+    # @return [ExecutionStringVellumValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      JSON.parse(json_object)
+      id = struct.id
+      name = struct.name
+      value = struct.value
+      new(id: id, name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ExecutionStringVellumValue 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?(String) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/execution_vellum_value.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "execution_string_vellum_value"
+require_relative "execution_number_vellum_value"
+require_relative "execution_json_vellum_value"
+require_relative "execution_chat_history_vellum_value"
+require_relative "execution_search_results_vellum_value"
+require_relative "execution_error_vellum_value"
+require_relative "execution_array_vellum_value"
+require_relative "execution_function_call_vellum_value"
+
+module Vellum
+  class ExecutionVellumValue
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [ExecutionVellumValue]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of ExecutionVellumValue
+    #
+    # @param json_object [JSON]
+    # @return [ExecutionVellumValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "STRING"
+                 ExecutionStringVellumValue.from_json(json_object: json_object)
+               when "NUMBER"
+                 ExecutionNumberVellumValue.from_json(json_object: json_object)
+               when "JSON"
+                 ExecutionJsonVellumValue.from_json(json_object: json_object)
+               when "CHAT_HISTORY"
+                 ExecutionChatHistoryVellumValue.from_json(json_object: json_object)
+               when "SEARCH_RESULTS"
+                 ExecutionSearchResultsVellumValue.from_json(json_object: json_object)
+               when "ERROR"
+                 ExecutionErrorVellumValue.from_json(json_object: json_object)
+               when "ARRAY"
+                 ExecutionArrayVellumValue.from_json(json_object: json_object)
+               when "FUNCTION_CALL"
+                 ExecutionFunctionCallVellumValue.from_json(json_object: json_object)
+               else
+                 ExecutionStringVellumValue.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
+      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
+      @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"
+        ExecutionStringVellumValue.validate_raw(obj: obj)
+      when "NUMBER"
+        ExecutionNumberVellumValue.validate_raw(obj: obj)
+      when "JSON"
+        ExecutionJsonVellumValue.validate_raw(obj: obj)
+      when "CHAT_HISTORY"
+        ExecutionChatHistoryVellumValue.validate_raw(obj: obj)
+      when "SEARCH_RESULTS"
+        ExecutionSearchResultsVellumValue.validate_raw(obj: obj)
+      when "ERROR"
+        ExecutionErrorVellumValue.validate_raw(obj: obj)
+      when "ARRAY"
+        ExecutionArrayVellumValue.validate_raw(obj: obj)
+      when "FUNCTION_CALL"
+        ExecutionFunctionCallVellumValue.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 [ExecutionStringVellumValue]
+    # @return [ExecutionVellumValue]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [ExecutionNumberVellumValue]
+    # @return [ExecutionVellumValue]
+    def self.number(member:)
+      new(member: member, discriminant: "NUMBER")
+    end
+
+    # @param member [ExecutionJsonVellumValue]
+    # @return [ExecutionVellumValue]
+    def self.json(member:)
+      new(member: member, discriminant: "JSON")
+    end
+
+    # @param member [ExecutionChatHistoryVellumValue]
+    # @return [ExecutionVellumValue]
+    def self.chat_history(member:)
+      new(member: member, discriminant: "CHAT_HISTORY")
+    end
+
+    # @param member [ExecutionSearchResultsVellumValue]
+    # @return [ExecutionVellumValue]
+    def self.search_results(member:)
+      new(member: member, discriminant: "SEARCH_RESULTS")
+    end
+
+    # @param member [ExecutionErrorVellumValue]
+    # @return [ExecutionVellumValue]
+    def self.error(member:)
+      new(member: member, discriminant: "ERROR")
+    end
+
+    # @param member [ExecutionArrayVellumValue]
+    # @return [ExecutionVellumValue]
+    def self.array(member:)
+      new(member: member, discriminant: "ARRAY")
+    end
+
+    # @param member [ExecutionFunctionCallVellumValue]
+    # @return [ExecutionVellumValue]
+    def self.function_call(member:)
+      new(member: member, discriminant: "FUNCTION_CALL")
+    end
+  end
+end

data/lib/vellum_ai/types/fulfilled_workflow_node_result_event.rb

@@ -8,17 +8,21 @@ require "json"
 module Vellum
   # An event that indicates that the node has fulfilled its execution.
   class FulfilledWorkflowNodeResultEvent
-    attr_reader :id, :node_id, :node_result_id, :ts, :data, :output_values, :additional_properties
+    attr_reader :id, :node_id, :node_result_id, :ts, :data, :source_execution_id, :output_values, :mocked,
+                :additional_properties
 
     # @param id [String]
     # @param node_id [String]
     # @param node_result_id [String]
     # @param ts [DateTime]
     # @param data [WorkflowNodeResultData]
+    # @param source_execution_id [String]
     # @param output_values [Array<NodeOutputCompiledValue>]
+    # @param mocked [Boolean]
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
     # @return [FulfilledWorkflowNodeResultEvent]
-    def initialize(id:, node_id:, node_result_id:, ts: nil, data: nil, output_values: nil, additional_properties: nil)
+    def initialize(id:, node_id:, node_result_id:, ts: nil, data: nil, source_execution_id: nil, output_values: nil,
+                   mocked: nil, additional_properties: nil)
       # @type [String]
       @id = id
       # @type [String]
@@ -29,8 +33,12 @@ module Vellum
       @ts = ts
       # @type [WorkflowNodeResultData]
       @data = data
+      # @type [String]
+      @source_execution_id = source_execution_id
       # @type [Array<NodeOutputCompiledValue>]
       @output_values = output_values
+      # @type [Boolean]
+      @mocked = mocked
       # @type [OpenStruct] Additional properties unmapped to the current class definition
       @additional_properties = additional_properties
     end
@@ -52,12 +60,14 @@ module Vellum
         data = parsed_json["data"].to_json
         data = WorkflowNodeResultData.from_json(json_object: data)
       end
+      source_execution_id = struct.source_execution_id
       output_values = parsed_json["output_values"].map do |v|
         v = v.to_json
         NodeOutputCompiledValue.from_json(json_object: v)
       end
-      new(id: id, node_id: node_id, node_result_id: node_result_id, ts: ts, data: data, output_values: output_values,
-          additional_properties: struct)
+      mocked = struct.mocked
+      new(id: id, node_id: node_id, node_result_id: node_result_id, ts: ts, data: data,
+          source_execution_id: source_execution_id, output_values: output_values, mocked: mocked, additional_properties: struct)
     end
 
     # Serialize an instance of FulfilledWorkflowNodeResultEvent to a JSON object
@@ -70,7 +80,9 @@ module Vellum
         "node_result_id": @node_result_id,
         "ts": @ts,
         "data": @data,
-        "output_values": @output_values
+        "source_execution_id": @source_execution_id,
+        "output_values": @output_values,
+        "mocked": @mocked
       }.to_json
     end
 
@@ -84,7 +96,9 @@ module Vellum
       obj.node_result_id.is_a?(String) != false || raise("Passed value for field obj.node_result_id 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.data.nil? || WorkflowNodeResultData.validate_raw(obj: obj.data)
+      obj.source_execution_id&.is_a?(String) != false || raise("Passed value for field obj.source_execution_id is not the expected type, validation failed.")
       obj.output_values&.is_a?(Array) != false || raise("Passed value for field obj.output_values is not the expected type, validation failed.")
+      obj.mocked&.is_a?(Boolean) != false || raise("Passed value for field obj.mocked is not the expected type, validation failed.")
     end
   end
 end

data/lib/vellum_ai/types/generate_request.rb

@@ -8,14 +8,14 @@ module Vellum
     attr_reader :input_values, :chat_history, :external_ids, :additional_properties
 
     # @param input_values [Hash{String => String}] Key/value pairs for each template variable defined in the deployment's prompt.
-    # @param chat_history [Array<ChatMessageRequest>] Optionally provide a list of chat messages that'll be used in place of the special {$chat_history} variable, if included in the prompt.
+    # @param chat_history [Array<ChatMessageRequest>] Optionally provide a list of chat messages that'll be used in place of the special chat_history variable, if included in the prompt.
     # @param external_ids [Array<String>] Optionally include a unique identifier for each generation, as represented outside of Vellum. Note that this should generally be a list of length one.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
     # @return [GenerateRequest]
     def initialize(input_values:, chat_history: nil, external_ids: nil, additional_properties: nil)
       # @type [Hash{String => String}] Key/value pairs for each template variable defined in the deployment's prompt.
       @input_values = input_values
-      # @type [Array<ChatMessageRequest>] Optionally provide a list of chat messages that'll be used in place of the special {$chat_history} variable, if included in the prompt.
+      # @type [Array<ChatMessageRequest>] Optionally provide a list of chat messages that'll be used in place of the special chat_history variable, if included in the prompt.
       @chat_history = chat_history
       # @type [Array<String>] Optionally include a unique identifier for each generation, as represented outside of Vellum. Note that this should generally be a list of length one.
       @external_ids = external_ids

data/lib/vellum_ai/types/image_variable_value.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "vellum_image"
+require "json"
+
+module Vellum
+  # A base Vellum primitive value representing an image.
+  class ImageVariableValue
+    attr_reader :value, :additional_properties
+
+    # @param value [VellumImage]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ImageVariableValue]
+    def initialize(value: nil, additional_properties: nil)
+      # @type [VellumImage]
+      @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 ImageVariableValue
+    #
+    # @param json_object [JSON]
+    # @return [ImageVariableValue]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["value"].nil?
+        value = nil
+      else
+        value = parsed_json["value"].to_json
+        value = VellumImage.from_json(json_object: value)
+      end
+      new(value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ImageVariableValue 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.nil? || VellumImage.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/initiated_workflow_node_result_event.rb

@@ -8,17 +8,19 @@ require "json"
 module Vellum
   # An event that indicates that the node has initiated its execution.
   class InitiatedWorkflowNodeResultEvent
-    attr_reader :id, :node_id, :node_result_id, :ts, :data, :input_values, :additional_properties
+    attr_reader :id, :node_id, :node_result_id, :ts, :data, :source_execution_id, :input_values, :additional_properties
 
     # @param id [String]
     # @param node_id [String]
     # @param node_result_id [String]
     # @param ts [DateTime]
     # @param data [WorkflowNodeResultData]
+    # @param source_execution_id [String]
     # @param input_values [Array<NodeInputVariableCompiledValue>]
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
     # @return [InitiatedWorkflowNodeResultEvent]
-    def initialize(id:, node_id:, node_result_id:, ts: nil, data: nil, input_values: nil, additional_properties: nil)
+    def initialize(id:, node_id:, node_result_id:, ts: nil, data: nil, source_execution_id: nil, input_values: nil,
+                   additional_properties: nil)
       # @type [String]
       @id = id
       # @type [String]
@@ -29,6 +31,8 @@ module Vellum
       @ts = ts
       # @type [WorkflowNodeResultData]
       @data = data
+      # @type [String]
+      @source_execution_id = source_execution_id
       # @type [Array<NodeInputVariableCompiledValue>]
       @input_values = input_values
       # @type [OpenStruct] Additional properties unmapped to the current class definition
@@ -52,12 +56,13 @@ module Vellum
         data = parsed_json["data"].to_json
         data = WorkflowNodeResultData.from_json(json_object: data)
       end
+      source_execution_id = struct.source_execution_id
       input_values = parsed_json["input_values"].map do |v|
         v = v.to_json
         NodeInputVariableCompiledValue.from_json(json_object: v)
       end
-      new(id: id, node_id: node_id, node_result_id: node_result_id, ts: ts, data: data, input_values: input_values,
-          additional_properties: struct)
+      new(id: id, node_id: node_id, node_result_id: node_result_id, ts: ts, data: data,
+          source_execution_id: source_execution_id, input_values: input_values, additional_properties: struct)
     end
 
     # Serialize an instance of InitiatedWorkflowNodeResultEvent to a JSON object
@@ -70,6 +75,7 @@ module Vellum
         "node_result_id": @node_result_id,
         "ts": @ts,
         "data": @data,
+        "source_execution_id": @source_execution_id,
         "input_values": @input_values
       }.to_json
     end
@@ -84,6 +90,7 @@ module Vellum
       obj.node_result_id.is_a?(String) != false || raise("Passed value for field obj.node_result_id 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.data.nil? || WorkflowNodeResultData.validate_raw(obj: obj.data)
+      obj.source_execution_id&.is_a?(String) != false || raise("Passed value for field obj.source_execution_id is not the expected type, validation failed.")
       obj.input_values&.is_a?(Array) != false || raise("Passed value for field obj.input_values is not the expected type, validation failed.")
     end
   end

data/lib/vellum_ai/types/prompt_template_block_properties.rb

@@ -7,11 +7,12 @@ require "json"
 
 module Vellum
   class PromptTemplateBlockProperties
-    attr_reader :chat_role, :chat_message_unterminated, :template, :template_type, :function_name,
+    attr_reader :chat_role, :chat_message_unterminated, :chat_source, :template, :template_type, :function_name,
                 :function_description, :function_parameters, :function_forced, :blocks, :additional_properties
 
     # @param chat_role [CHAT_MESSAGE_ROLE]
     # @param chat_message_unterminated [Boolean]
+    # @param chat_source [String]
     # @param template [String]
     # @param template_type [VELLUM_VARIABLE_TYPE]
     # @param function_name [String]
@@ -21,13 +22,15 @@ module Vellum
     # @param blocks [Array<PromptTemplateBlock>]
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
     # @return [PromptTemplateBlockProperties]
-    def initialize(chat_role: nil, chat_message_unterminated: nil, template: nil, template_type: nil,
+    def initialize(chat_role: nil, chat_message_unterminated: nil, chat_source: nil, template: nil, template_type: nil,
                    function_name: nil, function_description: nil, function_parameters: nil, function_forced: nil, blocks: nil, additional_properties: nil)
       # @type [CHAT_MESSAGE_ROLE]
       @chat_role = chat_role
       # @type [Boolean]
       @chat_message_unterminated = chat_message_unterminated
       # @type [String]
+      @chat_source = chat_source
+      # @type [String]
       @template = template
       # @type [VELLUM_VARIABLE_TYPE]
       @template_type = template_type
@@ -54,6 +57,7 @@ module Vellum
       parsed_json = JSON.parse(json_object)
       chat_role = CHAT_MESSAGE_ROLE.key(parsed_json["chat_role"]) || parsed_json["chat_role"]
       chat_message_unterminated = struct.chat_message_unterminated
+      chat_source = struct.chat_source
       template = struct.template
       template_type = VELLUM_VARIABLE_TYPE.key(parsed_json["template_type"]) || parsed_json["template_type"]
       function_name = struct.function_name
@@ -64,8 +68,8 @@ module Vellum
         v = v.to_json
         PromptTemplateBlock.from_json(json_object: v)
       end
-      new(chat_role: chat_role, chat_message_unterminated: chat_message_unterminated, template: template,
-          template_type: template_type, function_name: function_name, function_description: function_description, function_parameters: function_parameters, function_forced: function_forced, blocks: blocks, additional_properties: struct)
+      new(chat_role: chat_role, chat_message_unterminated: chat_message_unterminated, chat_source: chat_source,
+          template: template, template_type: template_type, function_name: function_name, function_description: function_description, function_parameters: function_parameters, function_forced: function_forced, blocks: blocks, additional_properties: struct)
     end
 
     # Serialize an instance of PromptTemplateBlockProperties to a JSON object
@@ -75,6 +79,7 @@ module Vellum
       {
         "chat_role": CHAT_MESSAGE_ROLE[@chat_role] || @chat_role,
         "chat_message_unterminated": @chat_message_unterminated,
+        "chat_source": @chat_source,
         "template": @template,
         "template_type": VELLUM_VARIABLE_TYPE[@template_type] || @template_type,
         "function_name": @function_name,
@@ -92,6 +97,7 @@ module Vellum
     def self.validate_raw(obj:)
       obj.chat_role&.is_a?(CHAT_MESSAGE_ROLE) != false || raise("Passed value for field obj.chat_role is not the expected type, validation failed.")
       obj.chat_message_unterminated&.is_a?(Boolean) != false || raise("Passed value for field obj.chat_message_unterminated is not the expected type, validation failed.")
+      obj.chat_source&.is_a?(String) != false || raise("Passed value for field obj.chat_source is not the expected type, validation failed.")
       obj.template&.is_a?(String) != false || raise("Passed value for field obj.template is not the expected type, validation failed.")
       obj.template_type&.is_a?(VELLUM_VARIABLE_TYPE) != false || raise("Passed value for field obj.template_type is not the expected type, validation failed.")
       obj.function_name&.is_a?(String) != false || raise("Passed value for field obj.function_name is not the expected type, validation failed.")