vellum_ai 0.3.14 → 0.14.74

data/lib/vellum_ai/types/slim_release_review.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require "date"
+require_relative "release_review_reviewer"
+require_relative "release_review_state"
+require "ostruct"
+require "json"
+
+module Vellum
+  class SlimReleaseReview
+  # @return [String] 
+    attr_reader :id
+  # @return [DateTime] 
+    attr_reader :created
+  # @return [Vellum::ReleaseReviewReviewer] 
+    attr_reader :reviewer
+  # @return [Vellum::ReleaseReviewState] 
+    attr_reader :state
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
+
+    # @param id [String] 
+    # @param created [DateTime] 
+    # @param reviewer [Vellum::ReleaseReviewReviewer] 
+    # @param state [Vellum::ReleaseReviewState] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::SlimReleaseReview]
+    def initialize(id:, created:, reviewer:, state:, additional_properties: nil)
+      @id = id
+      @created = created
+      @reviewer = reviewer
+      @state = state
+      @additional_properties = additional_properties
+      @_field_set = { "id": id, "created": created, "reviewer": reviewer, "state": state }
+    end
+# Deserialize a JSON object to an instance of SlimReleaseReview
+    #
+    # @param json_object [String] 
+    # @return [Vellum::SlimReleaseReview]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = parsed_json["id"]
+      created = unless parsed_json["created"].nil?
+  DateTime.parse(parsed_json["created"])
+else
+  nil
+end
+      unless parsed_json["reviewer"].nil?
+        reviewer = parsed_json["reviewer"].to_json
+        reviewer = Vellum::ReleaseReviewReviewer.from_json(json_object: reviewer)
+      else
+        reviewer = nil
+      end
+      state = parsed_json["state"]
+      new(
+        id: id,
+        created: created,
+        reviewer: reviewer,
+        state: state,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of SlimReleaseReview to a JSON object
+    #
+    # @return [String]
+    def to_json
+      @_field_set&.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.")
+      Vellum::ReleaseReviewReviewer.validate_raw(obj: obj.reviewer)
+      obj.state.is_a?(Vellum::ReleaseReviewState) != false || raise("Passed value for field obj.state is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/slim_workflow_deployment.rb

@@ -1,118 +1,150 @@
 # frozen_string_literal: true
-
 require_relative "entity_status"
 require_relative "environment_enum"
 require "date"
+require "date"
 require_relative "vellum_variable"
+require "ostruct"
 require "json"
 
 module Vellum
   class SlimWorkflowDeployment
-    attr_reader :id, :name, :label, :status, :environment, :created, :last_deployed_on, :input_variables,
-                :output_variables, :additional_properties
+  # @return [String] 
+    attr_reader :id
+  # @return [String] A name that uniquely identifies this workflow deployment within its workspace
+    attr_reader :name
+  # @return [String] A human-readable label for the workflow deployment
+    attr_reader :label
+  # @return [Vellum::EntityStatus] The current status of the workflow deployment
+#  * `ACTIVE` - Active
+#  * `ARCHIVED` - Archived
+    attr_reader :status
+  # @return [Vellum::EnvironmentEnum] The environment this workflow deployment is used in
+#  * `DEVELOPMENT` - Development
+#  * `STAGING` - Staging
+#  * `PRODUCTION` - Production
+    attr_reader :environment
+  # @return [DateTime] 
+    attr_reader :created
+  # @return [DateTime] 
+    attr_reader :last_deployed_on
+  # @return [Array<Vellum::VellumVariable>] The input variables this Workflow Deployment expects to receive values for when
+#  it is executed.
+    attr_reader :input_variables
+  # @return [Array<Vellum::VellumVariable>] The output variables this Workflow Deployment will produce when it is executed.
+    attr_reader :output_variables
+  # @return [String] A human-readable description of the workflow deployment
+    attr_reader :description
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param id [String]
+    # @param id [String] 
     # @param name [String] A name that uniquely identifies this workflow deployment within its workspace
     # @param label [String] A human-readable label for the workflow deployment
-    # @param status [ENTITY_STATUS] The current status of the workflow deployment
-    #   - `ACTIVE` - Active
-    #   - `ARCHIVED` - Archived
-    # @param environment [ENVIRONMENT_ENUM] The environment this workflow deployment is used in
-    #   - `DEVELOPMENT` - Development
-    #   - `STAGING` - Staging
-    #   - `PRODUCTION` - Production
-    # @param created [DateTime]
-    # @param last_deployed_on [DateTime]
-    # @param input_variables [Array<VellumVariable>] The input variables this Workflow Deployment expects to receive values for when it is executed.
-    # @param output_variables [Array<VellumVariable>] The output variables this Workflow Deployment will produce when it is executed.
+    # @param status [Vellum::EntityStatus] The current status of the workflow deployment
+#  * `ACTIVE` - Active
+#  * `ARCHIVED` - Archived
+    # @param environment [Vellum::EnvironmentEnum] The environment this workflow deployment is used in
+#  * `DEVELOPMENT` - Development
+#  * `STAGING` - Staging
+#  * `PRODUCTION` - Production
+    # @param created [DateTime] 
+    # @param last_deployed_on [DateTime] 
+    # @param input_variables [Array<Vellum::VellumVariable>] The input variables this Workflow Deployment expects to receive values for when
+#  it is executed.
+    # @param output_variables [Array<Vellum::VellumVariable>] The output variables this Workflow Deployment will produce when it is executed.
+    # @param description [String] A human-readable description of the workflow deployment
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [SlimWorkflowDeployment]
-    def initialize(id:, name:, label:, created:, last_deployed_on:, input_variables:, output_variables:, status: nil,
-                   environment: nil, additional_properties: nil)
-      # @type [String]
+    # @return [Vellum::SlimWorkflowDeployment]
+    def initialize(id:, name:, label:, status: OMIT, environment: OMIT, created:, last_deployed_on:, input_variables:, output_variables:, description: OMIT, additional_properties: nil)
       @id = id
-      # @type [String] A name that uniquely identifies this workflow deployment within its workspace
       @name = name
-      # @type [String] A human-readable label for the workflow deployment
       @label = label
-      # @type [ENTITY_STATUS] The current status of the workflow deployment
-      #   - `ACTIVE` - Active
-      #   - `ARCHIVED` - Archived
-      @status = status
-      # @type [ENVIRONMENT_ENUM] The environment this workflow deployment is used in
-      #   - `DEVELOPMENT` - Development
-      #   - `STAGING` - Staging
-      #   - `PRODUCTION` - Production
-      @environment = environment
-      # @type [DateTime]
+      @status = status if status != OMIT
+      @environment = environment if environment != OMIT
       @created = created
-      # @type [DateTime]
       @last_deployed_on = last_deployed_on
-      # @type [Array<VellumVariable>] The input variables this Workflow Deployment expects to receive values for when it is executed.
       @input_variables = input_variables
-      # @type [Array<VellumVariable>] The output variables this Workflow Deployment will produce when it is executed.
       @output_variables = output_variables
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @description = description if description != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "id": id, "name": name, "label": label, "status": status, "environment": environment, "created": created, "last_deployed_on": last_deployed_on, "input_variables": input_variables, "output_variables": output_variables, "description": description }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of SlimWorkflowDeployment
+# Deserialize a JSON object to an instance of SlimWorkflowDeployment
     #
-    # @param json_object [JSON]
-    # @return [SlimWorkflowDeployment]
+    # @param json_object [String] 
+    # @return [Vellum::SlimWorkflowDeployment]
     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
-      label = struct.label
-      status = ENTITY_STATUS.key(parsed_json["status"]) || parsed_json["status"]
-      environment = ENVIRONMENT_ENUM.key(parsed_json["environment"]) || parsed_json["environment"]
-      created = DateTime.parse(parsed_json["created"])
-      last_deployed_on = DateTime.parse(parsed_json["last_deployed_on"])
-      input_variables = parsed_json["input_variables"].map do |v|
-        v = v.to_json
-        VellumVariable.from_json(json_object: v)
-      end
-      output_variables = parsed_json["output_variables"].map do |v|
-        v = v.to_json
-        VellumVariable.from_json(json_object: v)
-      end
-      new(id: id, name: name, label: label, status: status, environment: environment, created: created,
-          last_deployed_on: last_deployed_on, input_variables: input_variables, output_variables: output_variables, additional_properties: struct)
+      id = parsed_json["id"]
+      name = parsed_json["name"]
+      label = parsed_json["label"]
+      status = parsed_json["status"]
+      environment = parsed_json["environment"]
+      created = unless parsed_json["created"].nil?
+  DateTime.parse(parsed_json["created"])
+else
+  nil
+end
+      last_deployed_on = unless parsed_json["last_deployed_on"].nil?
+  DateTime.parse(parsed_json["last_deployed_on"])
+else
+  nil
+end
+      input_variables = parsed_json["input_variables"]&.map do | item |
+  item = item.to_json
+  Vellum::VellumVariable.from_json(json_object: item)
+end
+      output_variables = parsed_json["output_variables"]&.map do | item |
+  item = item.to_json
+  Vellum::VellumVariable.from_json(json_object: item)
+end
+      description = parsed_json["description"]
+      new(
+        id: id,
+        name: name,
+        label: label,
+        status: status,
+        environment: environment,
+        created: created,
+        last_deployed_on: last_deployed_on,
+        input_variables: input_variables,
+        output_variables: output_variables,
+        description: description,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of SlimWorkflowDeployment to a JSON object
+# Serialize an instance of SlimWorkflowDeployment to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      {
-        "id": @id,
-        "name": @name,
-        "label": @label,
-        "status": ENTITY_STATUS[@status] || @status,
-        "environment": ENVIRONMENT_ENUM[@environment] || @environment,
-        "created": @created,
-        "last_deployed_on": @last_deployed_on,
-        "input_variables": @input_variables,
-        "output_variables": @output_variables
-      }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.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.
+# 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:)
       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.label.is_a?(String) != false || raise("Passed value for field obj.label 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.status&.is_a?(Vellum::EntityStatus) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
+      obj.environment&.is_a?(Vellum::EnvironmentEnum) != false || raise("Passed value for field obj.environment 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.last_deployed_on.is_a?(DateTime) != false || raise("Passed value for field obj.last_deployed_on is not the expected type, validation failed.")
       obj.input_variables.is_a?(Array) != false || raise("Passed value for field obj.input_variables is not the expected type, validation failed.")
       obj.output_variables.is_a?(Array) != false || raise("Passed value for field obj.output_variables is not the expected type, validation failed.")
+      obj.description&.is_a?(String) != false || raise("Passed value for field obj.description is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/slim_workflow_execution_read.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+require_relative "workflow_deployment_parent_context"
+require "date"
+require "date"
+require_relative "execution_vellum_value"
+require_relative "workflow_error"
+require_relative "workflow_execution_actual"
+require_relative "workflow_execution_view_online_eval_metric_result"
+require_relative "workflow_execution_usage_result"
+require "ostruct"
+require "json"
+
+module Vellum
+  class SlimWorkflowExecutionRead
+  # @return [String] 
+    attr_reader :span_id
+  # @return [Vellum::WorkflowDeploymentParentContext] 
+    attr_reader :parent_context
+  # @return [DateTime] 
+    attr_reader :start
+  # @return [DateTime] 
+    attr_reader :end_
+  # @return [Array<Vellum::ExecutionVellumValue>] 
+    attr_reader :inputs
+  # @return [Array<Vellum::ExecutionVellumValue>] 
+    attr_reader :outputs
+  # @return [Vellum::WorkflowError] 
+    attr_reader :error
+  # @return [Vellum::WorkflowExecutionActual] 
+    attr_reader :latest_actual
+  # @return [Array<Vellum::WorkflowExecutionViewOnlineEvalMetricResult>] 
+    attr_reader :metric_results
+  # @return [Array<Vellum::WorkflowExecutionUsageResult>] 
+    attr_reader :usage_results
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
+
+    # @param span_id [String] 
+    # @param parent_context [Vellum::WorkflowDeploymentParentContext] 
+    # @param start [DateTime] 
+    # @param end_ [DateTime] 
+    # @param inputs [Array<Vellum::ExecutionVellumValue>] 
+    # @param outputs [Array<Vellum::ExecutionVellumValue>] 
+    # @param error [Vellum::WorkflowError] 
+    # @param latest_actual [Vellum::WorkflowExecutionActual] 
+    # @param metric_results [Array<Vellum::WorkflowExecutionViewOnlineEvalMetricResult>] 
+    # @param usage_results [Array<Vellum::WorkflowExecutionUsageResult>] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::SlimWorkflowExecutionRead]
+    def initialize(span_id:, parent_context: OMIT, start:, end_: OMIT, inputs:, outputs:, error: OMIT, latest_actual: OMIT, metric_results:, usage_results: OMIT, additional_properties: nil)
+      @span_id = span_id
+      @parent_context = parent_context if parent_context != OMIT
+      @start = start
+      @end_ = end_ if end_ != OMIT
+      @inputs = inputs
+      @outputs = outputs
+      @error = error if error != OMIT
+      @latest_actual = latest_actual if latest_actual != OMIT
+      @metric_results = metric_results
+      @usage_results = usage_results if usage_results != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "span_id": span_id, "parent_context": parent_context, "start": start, "end": end_, "inputs": inputs, "outputs": outputs, "error": error, "latest_actual": latest_actual, "metric_results": metric_results, "usage_results": usage_results }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of SlimWorkflowExecutionRead
+    #
+    # @param json_object [String] 
+    # @return [Vellum::SlimWorkflowExecutionRead]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      span_id = parsed_json["span_id"]
+      unless parsed_json["parent_context"].nil?
+        parent_context = parsed_json["parent_context"].to_json
+        parent_context = Vellum::WorkflowDeploymentParentContext.from_json(json_object: parent_context)
+      else
+        parent_context = nil
+      end
+      start = unless parsed_json["start"].nil?
+  DateTime.parse(parsed_json["start"])
+else
+  nil
+end
+      end_ = unless parsed_json["end"].nil?
+  DateTime.parse(parsed_json["end"])
+else
+  nil
+end
+      inputs = parsed_json["inputs"]&.map do | item |
+  item = item.to_json
+  Vellum::ExecutionVellumValue.from_json(json_object: item)
+end
+      outputs = parsed_json["outputs"]&.map do | item |
+  item = item.to_json
+  Vellum::ExecutionVellumValue.from_json(json_object: item)
+end
+      unless parsed_json["error"].nil?
+        error = parsed_json["error"].to_json
+        error = Vellum::WorkflowError.from_json(json_object: error)
+      else
+        error = nil
+      end
+      unless parsed_json["latest_actual"].nil?
+        latest_actual = parsed_json["latest_actual"].to_json
+        latest_actual = Vellum::WorkflowExecutionActual.from_json(json_object: latest_actual)
+      else
+        latest_actual = nil
+      end
+      metric_results = parsed_json["metric_results"]&.map do | item |
+  item = item.to_json
+  Vellum::WorkflowExecutionViewOnlineEvalMetricResult.from_json(json_object: item)
+end
+      usage_results = parsed_json["usage_results"]&.map do | item |
+  item = item.to_json
+  Vellum::WorkflowExecutionUsageResult.from_json(json_object: item)
+end
+      new(
+        span_id: span_id,
+        parent_context: parent_context,
+        start: start,
+        end_: end_,
+        inputs: inputs,
+        outputs: outputs,
+        error: error,
+        latest_actual: latest_actual,
+        metric_results: metric_results,
+        usage_results: usage_results,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of SlimWorkflowExecutionRead to a JSON object
+    #
+    # @return [String]
+    def to_json
+      @_field_set&.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.span_id.is_a?(String) != false || raise("Passed value for field obj.span_id is not the expected type, validation failed.")
+      obj.parent_context.nil? || Vellum::WorkflowDeploymentParentContext.validate_raw(obj: obj.parent_context)
+      obj.start.is_a?(DateTime) != false || raise("Passed value for field obj.start is not the expected type, validation failed.")
+      obj.end_&.is_a?(DateTime) != false || raise("Passed value for field obj.end_ is not the expected type, validation failed.")
+      obj.inputs.is_a?(Array) != false || raise("Passed value for field obj.inputs is not the expected type, validation failed.")
+      obj.outputs.is_a?(Array) != false || raise("Passed value for field obj.outputs is not the expected type, validation failed.")
+      obj.error.nil? || Vellum::WorkflowError.validate_raw(obj: obj.error)
+      obj.latest_actual.nil? || Vellum::WorkflowExecutionActual.validate_raw(obj: obj.latest_actual)
+      obj.metric_results.is_a?(Array) != false || raise("Passed value for field obj.metric_results is not the expected type, validation failed.")
+      obj.usage_results&.is_a?(Array) != false || raise("Passed value for field obj.usage_results is not the expected type, validation failed.")
+    end
+  end
+end

data/lib/vellum_ai/types/span_link.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require_relative "span_link_type_enum"
+require_relative "parent_context"
+require "ostruct"
+require "json"
+
+module Vellum
+  class SpanLink
+  # @return [String] 
+    attr_reader :trace_id
+  # @return [Vellum::SPAN_LINK_TYPE_ENUM] 
+    attr_reader :type
+  # @return [Vellum::ParentContext] 
+    attr_reader :span_context
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
+
+    # @param trace_id [String] 
+    # @param type [Vellum::SPAN_LINK_TYPE_ENUM] 
+    # @param span_context [Vellum::ParentContext] 
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::SpanLink]
+    def initialize(trace_id:, type:, span_context:, additional_properties: nil)
+      @trace_id = trace_id
+      @type = type
+      @span_context = span_context
+      @additional_properties = additional_properties
+      @_field_set = { "trace_id": trace_id, "type": type, "span_context": span_context }
+    end
+# Deserialize a JSON object to an instance of SpanLink
+    #
+    # @param json_object [String] 
+    # @return [Vellum::SpanLink]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      trace_id = parsed_json["trace_id"]
+      type = parsed_json["type"]
+      unless parsed_json["span_context"].nil?
+        span_context = parsed_json["span_context"].to_json
+        span_context = Vellum::ParentContext.from_json(json_object: span_context)
+      else
+        span_context = nil
+      end
+      new(
+        trace_id: trace_id,
+        type: type,
+        span_context: span_context,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of SpanLink to a JSON object
+    #
+    # @return [String]
+    def to_json
+      @_field_set&.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.trace_id.is_a?(String) != false || raise("Passed value for field obj.trace_id is not the expected type, validation failed.")
+      obj.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      Vellum::ParentContext.validate_raw(obj: obj.span_context)
+    end
+  end
+end

data/lib/vellum_ai/types/{chat_history_enum.rb → span_link_type_enum.rb}

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

data/lib/vellum_ai/types/streaming_ad_hoc_execute_prompt_event.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+require_relative "prompt_output"
+require_relative "ad_hoc_streaming_prompt_execution_meta"
+require "ostruct"
+require "json"
+
+module Vellum
+# The data returned for each delta during the prompt execution stream.
+  class StreamingAdHocExecutePromptEvent
+  # @return [String] 
+    attr_reader :state
+  # @return [Vellum::PromptOutput] 
+    attr_reader :output
+  # @return [Integer] 
+    attr_reader :output_index
+  # @return [String] 
+    attr_reader :execution_id
+  # @return [Vellum::AdHocStreamingPromptExecutionMeta] 
+    attr_reader :meta
+  # @return [Hash{String => Object}] The subset of the raw response from the model that the request opted into with
+#  `expand_raw`.
+    attr_reader :raw
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
+
+    # @param state [String] 
+    # @param output [Vellum::PromptOutput] 
+    # @param output_index [Integer] 
+    # @param execution_id [String] 
+    # @param meta [Vellum::AdHocStreamingPromptExecutionMeta] 
+    # @param raw [Hash{String => Object}] The subset of the raw response from the model that the request opted into with
+#  `expand_raw`.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [Vellum::StreamingAdHocExecutePromptEvent]
+    def initialize(state:, output:, output_index:, execution_id:, meta: OMIT, raw: OMIT, additional_properties: nil)
+      @state = state
+      @output = output
+      @output_index = output_index
+      @execution_id = execution_id
+      @meta = meta if meta != OMIT
+      @raw = raw if raw != OMIT
+      @additional_properties = additional_properties
+      @_field_set = { "state": state, "output": output, "output_index": output_index, "execution_id": execution_id, "meta": meta, "raw": raw }.reject do | _k, v |
+  v == OMIT
+end
+    end
+# Deserialize a JSON object to an instance of StreamingAdHocExecutePromptEvent
+    #
+    # @param json_object [String] 
+    # @return [Vellum::StreamingAdHocExecutePromptEvent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      state = parsed_json["state"]
+      unless parsed_json["output"].nil?
+        output = parsed_json["output"].to_json
+        output = Vellum::PromptOutput.from_json(json_object: output)
+      else
+        output = nil
+      end
+      output_index = parsed_json["output_index"]
+      execution_id = parsed_json["execution_id"]
+      unless parsed_json["meta"].nil?
+        meta = parsed_json["meta"].to_json
+        meta = Vellum::AdHocStreamingPromptExecutionMeta.from_json(json_object: meta)
+      else
+        meta = nil
+      end
+      raw = parsed_json["raw"]
+      new(
+        state: state,
+        output: output,
+        output_index: output_index,
+        execution_id: execution_id,
+        meta: meta,
+        raw: raw,
+        additional_properties: struct
+      )
+    end
+# Serialize an instance of StreamingAdHocExecutePromptEvent to a JSON object
+    #
+    # @return [String]
+    def to_json
+      @_field_set&.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.state.is_a?(String) != false || raise("Passed value for field obj.state is not the expected type, validation failed.")
+      Vellum::PromptOutput.validate_raw(obj: obj.output)
+      obj.output_index.is_a?(Integer) != false || raise("Passed value for field obj.output_index is not the expected type, validation failed.")
+      obj.execution_id.is_a?(String) != false || raise("Passed value for field obj.execution_id is not the expected type, validation failed.")
+      obj.meta.nil? || Vellum::AdHocStreamingPromptExecutionMeta.validate_raw(obj: obj.meta)
+      obj.raw&.is_a?(Hash) != false || raise("Passed value for field obj.raw is not the expected type, validation failed.")
+    end
+  end
+end