vellum_ai 0.3.4

data/lib/vellum_ai/types/array_chat_message_content_request.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "array_chat_message_content_item_request"
+require "json"
+
+module Vellum
+  # A list of chat message content items.
+  class ArrayChatMessageContentRequest
+    attr_reader :value, :additional_properties
+
+    # @param value [Array<ArrayChatMessageContentItemRequest>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ArrayChatMessageContentRequest]
+    def initialize(value:, additional_properties: nil)
+      # @type [Array<ArrayChatMessageContentItemRequest>]
+      @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 ArrayChatMessageContentRequest
+    #
+    # @param json_object [JSON]
+    # @return [ArrayChatMessageContentRequest]
+    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
+        ArrayChatMessageContentItemRequest.from_json(json_object: v)
+      end
+      new(value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ArrayChatMessageContentRequest 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/block_type_enum.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [BLOCK_TYPE_ENUM]
+  BLOCK_TYPE_ENUM = {
+    chat_message: "CHAT_MESSAGE",
+    chat_history: "CHAT_HISTORY",
+    jinja: "JINJA",
+    function_definition: "FUNCTION_DEFINITION"
+  }.freeze
+end

data/lib/vellum_ai/types/chat_history_enum.rb

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

data/lib/vellum_ai/types/chat_history_input_request.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "chat_message_request"
+require "json"
+
+module Vellum
+  # A user input representing a list of chat messages
+  class ChatHistoryInputRequest
+    attr_reader :name, :value, :additional_properties
+
+    # @param name [String] The variable's name, as defined in the deployment.
+    # @param value [Array<ChatMessageRequest>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ChatHistoryInputRequest]
+    def initialize(name:, value:, additional_properties: nil)
+      # @type [String] The variable's name, as defined in the deployment.
+      @name = name
+      # @type [Array<ChatMessageRequest>]
+      @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 ChatHistoryInputRequest
+    #
+    # @param json_object [JSON]
+    # @return [ChatHistoryInputRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      name = struct.name
+      value = parsed_json["value"].map do |v|
+        v = v.to_json
+        ChatMessageRequest.from_json(json_object: v)
+      end
+      new(name: name, value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ChatHistoryInputRequest to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "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.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/chat_message.rb

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

data/lib/vellum_ai/types/chat_message_content.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "string_chat_message_content"
+require_relative "function_call_chat_message_content"
+require_relative "array_chat_message_content"
+require_relative "image_chat_message_content"
+
+module Vellum
+  class ChatMessageContent
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [ChatMessageContent]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of ChatMessageContent
+    #
+    # @param json_object [JSON]
+    # @return [ChatMessageContent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "STRING"
+                 StringChatMessageContent.from_json(json_object: json_object)
+               when "FUNCTION_CALL"
+                 FunctionCallChatMessageContent.from_json(json_object: json_object)
+               when "ARRAY"
+                 ArrayChatMessageContent.from_json(json_object: json_object)
+               when "IMAGE"
+                 ImageChatMessageContent.from_json(json_object: json_object)
+               else
+                 StringChatMessageContent.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 "FUNCTION_CALL"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "ARRAY"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "IMAGE"
+        { **@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"
+        StringChatMessageContent.validate_raw(obj: obj)
+      when "FUNCTION_CALL"
+        FunctionCallChatMessageContent.validate_raw(obj: obj)
+      when "ARRAY"
+        ArrayChatMessageContent.validate_raw(obj: obj)
+      when "IMAGE"
+        ImageChatMessageContent.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 [StringChatMessageContent]
+    # @return [ChatMessageContent]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [FunctionCallChatMessageContent]
+    # @return [ChatMessageContent]
+    def self.function_call(member:)
+      new(member: member, discriminant: "FUNCTION_CALL")
+    end
+
+    # @param member [ArrayChatMessageContent]
+    # @return [ChatMessageContent]
+    def self.array(member:)
+      new(member: member, discriminant: "ARRAY")
+    end
+
+    # @param member [ImageChatMessageContent]
+    # @return [ChatMessageContent]
+    def self.image(member:)
+      new(member: member, discriminant: "IMAGE")
+    end
+  end
+end

data/lib/vellum_ai/types/chat_message_content_request.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "string_chat_message_content_request"
+require_relative "function_call_chat_message_content_request"
+require_relative "array_chat_message_content_request"
+require_relative "image_chat_message_content_request"
+
+module Vellum
+  class ChatMessageContentRequest
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [ChatMessageContentRequest]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of ChatMessageContentRequest
+    #
+    # @param json_object [JSON]
+    # @return [ChatMessageContentRequest]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.type
+               when "STRING"
+                 StringChatMessageContentRequest.from_json(json_object: json_object)
+               when "FUNCTION_CALL"
+                 FunctionCallChatMessageContentRequest.from_json(json_object: json_object)
+               when "ARRAY"
+                 ArrayChatMessageContentRequest.from_json(json_object: json_object)
+               when "IMAGE"
+                 ImageChatMessageContentRequest.from_json(json_object: json_object)
+               else
+                 StringChatMessageContentRequest.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 "FUNCTION_CALL"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "ARRAY"
+        { **@member.to_json, type: @discriminant }.to_json
+      when "IMAGE"
+        { **@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"
+        StringChatMessageContentRequest.validate_raw(obj: obj)
+      when "FUNCTION_CALL"
+        FunctionCallChatMessageContentRequest.validate_raw(obj: obj)
+      when "ARRAY"
+        ArrayChatMessageContentRequest.validate_raw(obj: obj)
+      when "IMAGE"
+        ImageChatMessageContentRequest.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 [StringChatMessageContentRequest]
+    # @return [ChatMessageContentRequest]
+    def self.string(member:)
+      new(member: member, discriminant: "STRING")
+    end
+
+    # @param member [FunctionCallChatMessageContentRequest]
+    # @return [ChatMessageContentRequest]
+    def self.function_call(member:)
+      new(member: member, discriminant: "FUNCTION_CALL")
+    end
+
+    # @param member [ArrayChatMessageContentRequest]
+    # @return [ChatMessageContentRequest]
+    def self.array(member:)
+      new(member: member, discriminant: "ARRAY")
+    end
+
+    # @param member [ImageChatMessageContentRequest]
+    # @return [ChatMessageContentRequest]
+    def self.image(member:)
+      new(member: member, discriminant: "IMAGE")
+    end
+  end
+end

data/lib/vellum_ai/types/chat_message_request.rb

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

data/lib/vellum_ai/types/chat_message_role.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [CHAT_MESSAGE_ROLE]
+  CHAT_MESSAGE_ROLE = { system: "SYSTEM", assistant: "ASSISTANT", user: "USER", function: "FUNCTION" }.freeze
+end

data/lib/vellum_ai/types/code_execution_node_chat_history_result.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "chat_message"
+require "json"
+
+module Vellum
+  class CodeExecutionNodeChatHistoryResult
+    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 [CodeExecutionNodeChatHistoryResult]
+    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 CodeExecutionNodeChatHistoryResult
+    #
+    # @param json_object [JSON]
+    # @return [CodeExecutionNodeChatHistoryResult]
+    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 CodeExecutionNodeChatHistoryResult 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/code_execution_node_error_result.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "vellum_error"
+require "json"
+
+module Vellum
+  class CodeExecutionNodeErrorResult
+    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 [CodeExecutionNodeErrorResult]
+    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 CodeExecutionNodeErrorResult
+    #
+    # @param json_object [JSON]
+    # @return [CodeExecutionNodeErrorResult]
+    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 CodeExecutionNodeErrorResult 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/code_execution_node_json_result.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vellum
+  class CodeExecutionNodeJsonResult
+    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 [CodeExecutionNodeJsonResult]
+    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 CodeExecutionNodeJsonResult
+    #
+    # @param json_object [JSON]
+    # @return [CodeExecutionNodeJsonResult]
+    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 CodeExecutionNodeJsonResult 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