vellum_ai 0.3.4

data/lib/vellum_ai/types/document_document_to_document_index.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "indexing_state_enum"
+require "json"
+
+module Vellum
+  class DocumentDocumentToDocumentIndex
+    attr_reader :id, :document_index_id, :indexing_state, :additional_properties
+
+    # @param id [String] Vellum-generated ID that uniquely identifies this link.
+    # @param document_index_id [String] Vellum-generated ID that uniquely identifies the index this document is included in.
+    # @param indexing_state [INDEXING_STATE_ENUM] An enum value representing where this document is along its indexing lifecycle for this index.
+    #   - `AWAITING_PROCESSING` - Awaiting Processing
+    #   - `QUEUED` - Queued
+    #   - `INDEXING` - Indexing
+    #   - `INDEXED` - Indexed
+    #   - `FAILED` - Failed
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [DocumentDocumentToDocumentIndex]
+    def initialize(id:, document_index_id:, indexing_state: nil, additional_properties: nil)
+      # @type [String] Vellum-generated ID that uniquely identifies this link.
+      @id = id
+      # @type [String] Vellum-generated ID that uniquely identifies the index this document is included in.
+      @document_index_id = document_index_id
+      # @type [INDEXING_STATE_ENUM] An enum value representing where this document is along its indexing lifecycle for this index.
+      #   - `AWAITING_PROCESSING` - Awaiting Processing
+      #   - `QUEUED` - Queued
+      #   - `INDEXING` - Indexing
+      #   - `INDEXED` - Indexed
+      #   - `FAILED` - Failed
+      @indexing_state = indexing_state
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of DocumentDocumentToDocumentIndex
+    #
+    # @param json_object [JSON]
+    # @return [DocumentDocumentToDocumentIndex]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      document_index_id = struct.document_index_id
+      indexing_state = INDEXING_STATE_ENUM.key(parsed_json["indexing_state"]) || parsed_json["indexing_state"]
+      new(id: id, document_index_id: document_index_id, indexing_state: indexing_state, additional_properties: struct)
+    end
+
+    # Serialize an instance of DocumentDocumentToDocumentIndex to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "id": @id,
+        "document_index_id": @document_index_id,
+        "indexing_state": INDEXING_STATE_ENUM[@indexing_state] || @indexing_state
+      }.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.document_index_id.is_a?(String) != false || raise("Passed value for field obj.document_index_id is not the expected type, validation failed.")
+      obj.indexing_state&.is_a?(INDEXING_STATE_ENUM) != false || raise("Passed value for field obj.indexing_state is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/document_index_read.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "entity_status"
+require_relative "environment_enum"
+require "json"
+
+module Vellum
+  class DocumentIndexRead
+    attr_reader :id, :created, :label, :name, :status, :environment, :indexing_config, :additional_properties
+
+    # @param id [String]
+    # @param created [DateTime]
+    # @param label [String] A human-readable label for the document index
+    # @param name [String] A name that uniquely identifies this index within its workspace
+    # @param status [ENTITY_STATUS] The current status of the document index
+    #   - `ACTIVE` - Active
+    #   - `ARCHIVED` - Archived
+    # @param environment [ENVIRONMENT_ENUM] The environment this document index is used in
+    #   - `DEVELOPMENT` - Development
+    #   - `STAGING` - Staging
+    #   - `PRODUCTION` - Production
+    # @param indexing_config [Hash{String => String}] Configuration representing how documents should be indexed
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [DocumentIndexRead]
+    def initialize(id:, created:, label:, name:, indexing_config:, status: nil, environment: nil,
+                   additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [DateTime]
+      @created = created
+      # @type [String] A human-readable label for the document index
+      @label = label
+      # @type [String] A name that uniquely identifies this index within its workspace
+      @name = name
+      # @type [ENTITY_STATUS] The current status of the document index
+      #   - `ACTIVE` - Active
+      #   - `ARCHIVED` - Archived
+      @status = status
+      # @type [ENVIRONMENT_ENUM] The environment this document index is used in
+      #   - `DEVELOPMENT` - Development
+      #   - `STAGING` - Staging
+      #   - `PRODUCTION` - Production
+      @environment = environment
+      # @type [Hash{String => String}] Configuration representing how documents should be indexed
+      @indexing_config = indexing_config
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of DocumentIndexRead
+    #
+    # @param json_object [JSON]
+    # @return [DocumentIndexRead]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      created = DateTime.parse(parsed_json["created"])
+      label = struct.label
+      name = struct.name
+      status = ENTITY_STATUS.key(parsed_json["status"]) || parsed_json["status"]
+      environment = ENVIRONMENT_ENUM.key(parsed_json["environment"]) || parsed_json["environment"]
+      indexing_config = struct.indexing_config
+      new(id: id, created: created, label: label, name: name, status: status, environment: environment,
+          indexing_config: indexing_config, additional_properties: struct)
+    end
+
+    # Serialize an instance of DocumentIndexRead to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "id": @id,
+        "created": @created,
+        "label": @label,
+        "name": @name,
+        "status": ENTITY_STATUS[@status] || @status,
+        "environment": ENVIRONMENT_ENUM[@environment] || @environment,
+        "indexing_config": @indexing_config
+      }.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.created.is_a?(DateTime) != false || raise("Passed value for field obj.created is not the expected type, validation failed.")
+      obj.label.is_a?(String) != false || raise("Passed value for field obj.label is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.status&.is_a?(ENTITY_STATUS) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
+      obj.environment&.is_a?(ENVIRONMENT_ENUM) != false || raise("Passed value for field obj.environment is not the expected type, validation failed.")
+      obj.indexing_config.is_a?(Hash) != false || raise("Passed value for field obj.indexing_config is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/document_read.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "processing_state_enum"
+require_relative "document_status"
+require_relative "document_document_to_document_index"
+require "json"
+
+module Vellum
+  class DocumentRead
+    attr_reader :id, :external_id, :last_uploaded_at, :label, :processing_state, :status, :original_file_url,
+                :processed_file_url, :document_to_document_indexes, :metadata, :additional_properties
+
+    # @param id [String]
+    # @param external_id [String] The unique id of this document as it exists in the user's system.
+    # @param last_uploaded_at [DateTime]
+    # @param label [String] A human-readable label for the document. Defaults to the originally uploaded file's file name.
+    # @param processing_state [PROCESSING_STATE_ENUM] The current processing state of the document
+    #   - `QUEUED` - Queued
+    #   - `PROCESSING` - Processing
+    #   - `PROCESSED` - Processed
+    #   - `FAILED` - Failed
+    # @param status [DOCUMENT_STATUS] The current status of the document
+    #   - `ACTIVE` - Active
+    # @param original_file_url [String]
+    # @param processed_file_url [String]
+    # @param document_to_document_indexes [Array<DocumentDocumentToDocumentIndex>]
+    # @param metadata [Hash{String => String}] A previously supplied JSON object containing metadata that can be filtered on when searching.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [DocumentRead]
+    def initialize(id:, last_uploaded_at:, label:, document_to_document_indexes:, external_id: nil, processing_state: nil, status: nil,
+                   original_file_url: nil, processed_file_url: nil, metadata: nil, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [String] The unique id of this document as it exists in the user's system.
+      @external_id = external_id
+      # @type [DateTime]
+      @last_uploaded_at = last_uploaded_at
+      # @type [String] A human-readable label for the document. Defaults to the originally uploaded file's file name.
+      @label = label
+      # @type [PROCESSING_STATE_ENUM] The current processing state of the document
+      #   - `QUEUED` - Queued
+      #   - `PROCESSING` - Processing
+      #   - `PROCESSED` - Processed
+      #   - `FAILED` - Failed
+      @processing_state = processing_state
+      # @type [DOCUMENT_STATUS] The current status of the document
+      #   - `ACTIVE` - Active
+      @status = status
+      # @type [String]
+      @original_file_url = original_file_url
+      # @type [String]
+      @processed_file_url = processed_file_url
+      # @type [Array<DocumentDocumentToDocumentIndex>]
+      @document_to_document_indexes = document_to_document_indexes
+      # @type [Hash{String => String}] A previously supplied JSON object containing metadata that can be filtered on when searching.
+      @metadata = metadata
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of DocumentRead
+    #
+    # @param json_object [JSON]
+    # @return [DocumentRead]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      external_id = struct.external_id
+      last_uploaded_at = DateTime.parse(parsed_json["last_uploaded_at"])
+      label = struct.label
+      processing_state = PROCESSING_STATE_ENUM.key(parsed_json["processing_state"]) || parsed_json["processing_state"]
+      status = struct.status
+      original_file_url = struct.original_file_url
+      processed_file_url = struct.processed_file_url
+      document_to_document_indexes = parsed_json["document_to_document_indexes"].map do |v|
+        v = v.to_json
+        DocumentDocumentToDocumentIndex.from_json(json_object: v)
+      end
+      metadata = struct.metadata
+      new(id: id, external_id: external_id, last_uploaded_at: last_uploaded_at, label: label,
+          processing_state: processing_state, status: status, original_file_url: original_file_url, processed_file_url: processed_file_url, document_to_document_indexes: document_to_document_indexes, metadata: metadata, additional_properties: struct)
+    end
+
+    # Serialize an instance of DocumentRead to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "id": @id,
+        "external_id": @external_id,
+        "last_uploaded_at": @last_uploaded_at,
+        "label": @label,
+        "processing_state": PROCESSING_STATE_ENUM[@processing_state] || @processing_state,
+        "status": @status,
+        "original_file_url": @original_file_url,
+        "processed_file_url": @processed_file_url,
+        "document_to_document_indexes": @document_to_document_indexes,
+        "metadata": @metadata
+      }.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.external_id&.is_a?(String) != false || raise("Passed value for field obj.external_id is not the expected type, validation failed.")
+      obj.last_uploaded_at.is_a?(DateTime) != false || raise("Passed value for field obj.last_uploaded_at is not the expected type, validation failed.")
+      obj.label.is_a?(String) != false || raise("Passed value for field obj.label is not the expected type, validation failed.")
+      obj.processing_state&.is_a?(PROCESSING_STATE_ENUM) != false || raise("Passed value for field obj.processing_state is not the expected type, validation failed.")
+      obj.status&.is_a?(String) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
+      obj.original_file_url&.is_a?(String) != false || raise("Passed value for field obj.original_file_url is not the expected type, validation failed.")
+      obj.processed_file_url&.is_a?(String) != false || raise("Passed value for field obj.processed_file_url is not the expected type, validation failed.")
+      obj.document_to_document_indexes.is_a?(Array) != false || raise("Passed value for field obj.document_to_document_indexes is not the expected type, validation failed.")
+      obj.metadata&.is_a?(Hash) != false || raise("Passed value for field obj.metadata is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/document_status.rb

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

data/lib/vellum_ai/types/enriched_normalized_completion.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "finish_reason_enum"
+require_relative "normalized_log_probs"
+require_relative "vellum_variable_type"
+require "json"
+
+module Vellum
+  class EnrichedNormalizedCompletion
+    attr_reader :id, :external_id, :text, :finish_reason, :logprobs, :model_version_id, :prompt_version_id, :type,
+                :deployment_release_tag, :model_name, :additional_properties
+
+    # @param id [String] The Vellum-generated ID of the completion.
+    # @param external_id [String] The external ID that was originally provided along with the generation request, which uniquely identifies this generation in an external system.
+    # @param text [String] The text generated by the LLM.
+    # @param finish_reason [FINISH_REASON_ENUM] The reason the generation finished.
+    #   - `LENGTH` - LENGTH
+    #   - `STOP` - STOP
+    #   - `UNKNOWN` - UNKNOWN
+    # @param logprobs [NormalizedLogProbs] The logprobs of the completion. Only present if specified in the original request options.
+    # @param model_version_id [String] The ID of the model version used to generate this completion.
+    # @param prompt_version_id [String]
+    # @param type [VELLUM_VARIABLE_TYPE]
+    # @param deployment_release_tag [String]
+    # @param model_name [String]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [EnrichedNormalizedCompletion]
+    def initialize(id:, text:, model_version_id:, prompt_version_id:, deployment_release_tag:, model_name:,
+                   external_id: nil, finish_reason: nil, logprobs: nil, type: nil, additional_properties: nil)
+      # @type [String] The Vellum-generated ID of the completion.
+      @id = id
+      # @type [String] The external ID that was originally provided along with the generation request, which uniquely identifies this generation in an external system.
+      @external_id = external_id
+      # @type [String] The text generated by the LLM.
+      @text = text
+      # @type [FINISH_REASON_ENUM] The reason the generation finished.
+      #   - `LENGTH` - LENGTH
+      #   - `STOP` - STOP
+      #   - `UNKNOWN` - UNKNOWN
+      @finish_reason = finish_reason
+      # @type [NormalizedLogProbs] The logprobs of the completion. Only present if specified in the original request options.
+      @logprobs = logprobs
+      # @type [String] The ID of the model version used to generate this completion.
+      @model_version_id = model_version_id
+      # @type [String]
+      @prompt_version_id = prompt_version_id
+      # @type [VELLUM_VARIABLE_TYPE]
+      @type = type
+      # @type [String]
+      @deployment_release_tag = deployment_release_tag
+      # @type [String]
+      @model_name = model_name
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of EnrichedNormalizedCompletion
+    #
+    # @param json_object [JSON]
+    # @return [EnrichedNormalizedCompletion]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      external_id = struct.external_id
+      text = struct.text
+      finish_reason = FINISH_REASON_ENUM.key(parsed_json["finish_reason"]) || parsed_json["finish_reason"]
+      if parsed_json["logprobs"].nil?
+        logprobs = nil
+      else
+        logprobs = parsed_json["logprobs"].to_json
+        logprobs = NormalizedLogProbs.from_json(json_object: logprobs)
+      end
+      model_version_id = struct.model_version_id
+      prompt_version_id = struct.prompt_version_id
+      type = VELLUM_VARIABLE_TYPE.key(parsed_json["type"]) || parsed_json["type"]
+      deployment_release_tag = struct.deployment_release_tag
+      model_name = struct.model_name
+      new(id: id, external_id: external_id, text: text, finish_reason: finish_reason, logprobs: logprobs,
+          model_version_id: model_version_id, prompt_version_id: prompt_version_id, type: type, deployment_release_tag: deployment_release_tag, model_name: model_name, additional_properties: struct)
+    end
+
+    # Serialize an instance of EnrichedNormalizedCompletion to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      {
+        "id": @id,
+        "external_id": @external_id,
+        "text": @text,
+        "finish_reason": FINISH_REASON_ENUM[@finish_reason] || @finish_reason,
+        "logprobs": @logprobs,
+        "model_version_id": @model_version_id,
+        "prompt_version_id": @prompt_version_id,
+        "type": VELLUM_VARIABLE_TYPE[@type] || @type,
+        "deployment_release_tag": @deployment_release_tag,
+        "model_name": @model_name
+      }.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.external_id&.is_a?(String) != false || raise("Passed value for field obj.external_id is not the expected type, validation failed.")
+      obj.text.is_a?(String) != false || raise("Passed value for field obj.text is not the expected type, validation failed.")
+      obj.finish_reason&.is_a?(FINISH_REASON_ENUM) != false || raise("Passed value for field obj.finish_reason is not the expected type, validation failed.")
+      obj.logprobs.nil? || NormalizedLogProbs.validate_raw(obj: obj.logprobs)
+      obj.model_version_id.is_a?(String) != false || raise("Passed value for field obj.model_version_id is not the expected type, validation failed.")
+      obj.prompt_version_id.is_a?(String) != false || raise("Passed value for field obj.prompt_version_id is not the expected type, validation failed.")
+      obj.type&.is_a?(VELLUM_VARIABLE_TYPE) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      obj.deployment_release_tag.is_a?(String) != false || raise("Passed value for field obj.deployment_release_tag is not the expected type, validation failed.")
+      obj.model_name.is_a?(String) != false || raise("Passed value for field obj.model_name is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/entity_status.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [ENTITY_STATUS]
+  ENTITY_STATUS = { active: "ACTIVE", archived: "ARCHIVED" }.freeze
+end

data/lib/vellum_ai/types/environment_enum.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [ENVIRONMENT_ENUM]
+  ENVIRONMENT_ENUM = { development: "DEVELOPMENT", staging: "STAGING", production: "PRODUCTION" }.freeze
+end

data/lib/vellum_ai/types/error_enum.rb

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

data/lib/vellum_ai/types/error_variable_value.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "vellum_error"
+require "json"
+
+module Vellum
+  class ErrorVariableValue
+    attr_reader :value, :additional_properties
+
+    # @param value [VellumError]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [ErrorVariableValue]
+    def initialize(value: nil, additional_properties: nil)
+      # @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 ErrorVariableValue
+    #
+    # @param json_object [JSON]
+    # @return [ErrorVariableValue]
+    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 = VellumError.from_json(json_object: value)
+      end
+      new(value: value, additional_properties: struct)
+    end
+
+    # Serialize an instance of ErrorVariableValue 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? || VellumError.validate_raw(obj: obj.value)
+    end
+  end
+end

data/lib/vellum_ai/types/execute_prompt_api_error_response.rb

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

data/lib/vellum_ai/types/execute_prompt_event.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "initiated_execute_prompt_event"
+require_relative "streaming_execute_prompt_event"
+require_relative "fulfilled_execute_prompt_event"
+require_relative "rejected_execute_prompt_event"
+
+module Vellum
+  class ExecutePromptEvent
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [ExecutePromptEvent]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of ExecutePromptEvent
+    #
+    # @param json_object [JSON]
+    # @return [ExecutePromptEvent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.state
+               when "INITIATED"
+                 InitiatedExecutePromptEvent.from_json(json_object: json_object)
+               when "STREAMING"
+                 StreamingExecutePromptEvent.from_json(json_object: json_object)
+               when "FULFILLED"
+                 FulfilledExecutePromptEvent.from_json(json_object: json_object)
+               when "REJECTED"
+                 RejectedExecutePromptEvent.from_json(json_object: json_object)
+               else
+                 InitiatedExecutePromptEvent.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
+      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.state
+      when "INITIATED"
+        InitiatedExecutePromptEvent.validate_raw(obj: obj)
+      when "STREAMING"
+        StreamingExecutePromptEvent.validate_raw(obj: obj)
+      when "FULFILLED"
+        FulfilledExecutePromptEvent.validate_raw(obj: obj)
+      when "REJECTED"
+        RejectedExecutePromptEvent.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 [InitiatedExecutePromptEvent]
+    # @return [ExecutePromptEvent]
+    def self.initiated(member:)
+      new(member: member, discriminant: "INITIATED")
+    end
+
+    # @param member [StreamingExecutePromptEvent]
+    # @return [ExecutePromptEvent]
+    def self.streaming(member:)
+      new(member: member, discriminant: "STREAMING")
+    end
+
+    # @param member [FulfilledExecutePromptEvent]
+    # @return [ExecutePromptEvent]
+    def self.fulfilled(member:)
+      new(member: member, discriminant: "FULFILLED")
+    end
+
+    # @param member [RejectedExecutePromptEvent]
+    # @return [ExecutePromptEvent]
+    def self.rejected(member:)
+      new(member: member, discriminant: "REJECTED")
+    end
+  end
+end