vellum_ai 0.3.4

data/lib/vellum_ai/types/execute_prompt_response.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "fulfilled_execute_prompt_response"
+require_relative "rejected_execute_prompt_response"
+
+module Vellum
+  class ExecutePromptResponse
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [ExecutePromptResponse]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of ExecutePromptResponse
+    #
+    # @param json_object [JSON]
+    # @return [ExecutePromptResponse]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.state
+               when "FULFILLED"
+                 FulfilledExecutePromptResponse.from_json(json_object: json_object)
+               when "REJECTED"
+                 RejectedExecutePromptResponse.from_json(json_object: json_object)
+               else
+                 FulfilledExecutePromptResponse.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 "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 "FULFILLED"
+        FulfilledExecutePromptResponse.validate_raw(obj: obj)
+      when "REJECTED"
+        RejectedExecutePromptResponse.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 [FulfilledExecutePromptResponse]
+    # @return [ExecutePromptResponse]
+    def self.fulfilled(member:)
+      new(member: member, discriminant: "FULFILLED")
+    end
+
+    # @param member [RejectedExecutePromptResponse]
+    # @return [ExecutePromptResponse]
+    def self.rejected(member:)
+      new(member: member, discriminant: "REJECTED")
+    end
+  end
+end

data/lib/vellum_ai/types/execute_workflow_error_response.rb

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

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

data/lib/vellum_ai/types/execute_workflow_stream_error_response.rb

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "fulfilled_execute_workflow_workflow_result_event"
+require_relative "rejected_execute_workflow_workflow_result_event"
+
+module Vellum
+  class ExecuteWorkflowWorkflowResultEvent
+    attr_reader :member, :discriminant
+
+    private_class_method :new
+    alias kind_of? is_a?
+    # @param member [Object]
+    # @param discriminant [String]
+    # @return [ExecuteWorkflowWorkflowResultEvent]
+    def initialize(member:, discriminant:)
+      # @type [Object]
+      @member = member
+      # @type [String]
+      @discriminant = discriminant
+    end
+
+    # Deserialize a JSON object to an instance of ExecuteWorkflowWorkflowResultEvent
+    #
+    # @param json_object [JSON]
+    # @return [ExecuteWorkflowWorkflowResultEvent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      member = case struct.state
+               when "FULFILLED"
+                 FulfilledExecuteWorkflowWorkflowResultEvent.from_json(json_object: json_object)
+               when "REJECTED"
+                 RejectedExecuteWorkflowWorkflowResultEvent.from_json(json_object: json_object)
+               else
+                 FulfilledExecuteWorkflowWorkflowResultEvent.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 "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 "FULFILLED"
+        FulfilledExecuteWorkflowWorkflowResultEvent.validate_raw(obj: obj)
+      when "REJECTED"
+        RejectedExecuteWorkflowWorkflowResultEvent.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 [FulfilledExecuteWorkflowWorkflowResultEvent]
+    # @return [ExecuteWorkflowWorkflowResultEvent]
+    def self.fulfilled(member:)
+      new(member: member, discriminant: "FULFILLED")
+    end
+
+    # @param member [RejectedExecuteWorkflowWorkflowResultEvent]
+    # @return [ExecuteWorkflowWorkflowResultEvent]
+    def self.rejected(member:)
+      new(member: member, discriminant: "REJECTED")
+    end
+  end
+end

data/lib/vellum_ai/types/finish_reason_enum.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Vellum
+  # @type [FINISH_REASON_ENUM]
+  FINISH_REASON_ENUM = { length: "LENGTH", stop: "STOP", unknown: "UNKNOWN" }.freeze
+end

data/lib/vellum_ai/types/fulfilled_enum.rb

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

data/lib/vellum_ai/types/fulfilled_execute_prompt_event.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "prompt_output"
+require_relative "fulfilled_prompt_execution_meta"
+require "json"
+
+module Vellum
+  # The final data event returned indicating that the stream has ended and all final resolved values from the model can be found.
+  class FulfilledExecutePromptEvent
+    attr_reader :outputs, :execution_id, :meta, :additional_properties
+
+    # @param outputs [Array<PromptOutput>]
+    # @param execution_id [String]
+    # @param meta [FulfilledPromptExecutionMeta]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [FulfilledExecutePromptEvent]
+    def initialize(outputs:, execution_id:, meta: nil, additional_properties: nil)
+      # @type [Array<PromptOutput>]
+      @outputs = outputs
+      # @type [String]
+      @execution_id = execution_id
+      # @type [FulfilledPromptExecutionMeta]
+      @meta = meta
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of FulfilledExecutePromptEvent
+    #
+    # @param json_object [JSON]
+    # @return [FulfilledExecutePromptEvent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      outputs = parsed_json["outputs"].map do |v|
+        v = v.to_json
+        PromptOutput.from_json(json_object: v)
+      end
+      execution_id = struct.execution_id
+      if parsed_json["meta"].nil?
+        meta = nil
+      else
+        meta = parsed_json["meta"].to_json
+        meta = FulfilledPromptExecutionMeta.from_json(json_object: meta)
+      end
+      new(outputs: outputs, execution_id: execution_id, meta: meta, additional_properties: struct)
+    end
+
+    # Serialize an instance of FulfilledExecutePromptEvent to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "outputs": @outputs, "execution_id": @execution_id, "meta": @meta }.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.outputs.is_a?(Array) != false || raise("Passed value for field obj.outputs 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? || FulfilledPromptExecutionMeta.validate_raw(obj: obj.meta)
+    end
+  end
+end

data/lib/vellum_ai/types/fulfilled_execute_prompt_response.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "prompt_execution_meta"
+require_relative "prompt_output"
+require "json"
+
+module Vellum
+  # The successful response from the model containing all of the resolved values generated by the prompt.
+  class FulfilledExecutePromptResponse
+    attr_reader :meta, :raw, :execution_id, :outputs, :additional_properties
+
+    # @param meta [PromptExecutionMeta]
+    # @param raw [Hash{String => String}] The subset of the raw response from the model that the request opted into with `expand_raw`.
+    # @param execution_id [String] The ID of the execution.
+    # @param outputs [Array<PromptOutput>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [FulfilledExecutePromptResponse]
+    def initialize(execution_id:, outputs:, meta: nil, raw: nil, additional_properties: nil)
+      # @type [PromptExecutionMeta]
+      @meta = meta
+      # @type [Hash{String => String}] The subset of the raw response from the model that the request opted into with `expand_raw`.
+      @raw = raw
+      # @type [String] The ID of the execution.
+      @execution_id = execution_id
+      # @type [Array<PromptOutput>]
+      @outputs = outputs
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of FulfilledExecutePromptResponse
+    #
+    # @param json_object [JSON]
+    # @return [FulfilledExecutePromptResponse]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      if parsed_json["meta"].nil?
+        meta = nil
+      else
+        meta = parsed_json["meta"].to_json
+        meta = PromptExecutionMeta.from_json(json_object: meta)
+      end
+      raw = struct.raw
+      execution_id = struct.execution_id
+      outputs = parsed_json["outputs"].map do |v|
+        v = v.to_json
+        PromptOutput.from_json(json_object: v)
+      end
+      new(meta: meta, raw: raw, execution_id: execution_id, outputs: outputs, additional_properties: struct)
+    end
+
+    # Serialize an instance of FulfilledExecutePromptResponse to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "meta": @meta, "raw": @raw, "execution_id": @execution_id, "outputs": @outputs }.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.meta.nil? || PromptExecutionMeta.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.")
+      obj.execution_id.is_a?(String) != false || raise("Passed value for field obj.execution_id 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.")
+    end
+  end
+end

data/lib/vellum_ai/types/fulfilled_execute_workflow_workflow_result_event.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "workflow_output"
+require "json"
+
+module Vellum
+  # The successful response from the Workflow execution containing the produced outputs.
+  class FulfilledExecuteWorkflowWorkflowResultEvent
+    attr_reader :id, :ts, :outputs, :additional_properties
+
+    # @param id [String]
+    # @param ts [DateTime]
+    # @param outputs [Array<WorkflowOutput>]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [FulfilledExecuteWorkflowWorkflowResultEvent]
+    def initialize(id:, ts:, outputs:, additional_properties: nil)
+      # @type [String]
+      @id = id
+      # @type [DateTime]
+      @ts = ts
+      # @type [Array<WorkflowOutput>]
+      @outputs = outputs
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of FulfilledExecuteWorkflowWorkflowResultEvent
+    #
+    # @param json_object [JSON]
+    # @return [FulfilledExecuteWorkflowWorkflowResultEvent]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      id = struct.id
+      ts = DateTime.parse(parsed_json["ts"])
+      outputs = parsed_json["outputs"].map do |v|
+        v = v.to_json
+        WorkflowOutput.from_json(json_object: v)
+      end
+      new(id: id, ts: ts, outputs: outputs, additional_properties: struct)
+    end
+
+    # Serialize an instance of FulfilledExecuteWorkflowWorkflowResultEvent to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "id": @id, "ts": @ts, "outputs": @outputs }.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.ts.is_a?(DateTime) != false || raise("Passed value for field obj.ts 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.")
+    end
+  end
+end

data/lib/vellum_ai/types/fulfilled_function_call.rb

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

data/lib/vellum_ai/types/fulfilled_prompt_execution_meta.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "finish_reason_enum"
+require "json"
+
+module Vellum
+  # The subset of the metadata tracked by Vellum during prompt execution that the request opted into with `expand_meta`.
+  class FulfilledPromptExecutionMeta
+    attr_reader :latency, :finish_reason, :additional_properties
+
+    # @param latency [Integer]
+    # @param finish_reason [FINISH_REASON_ENUM]
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @return [FulfilledPromptExecutionMeta]
+    def initialize(latency: nil, finish_reason: nil, additional_properties: nil)
+      # @type [Integer]
+      @latency = latency
+      # @type [FINISH_REASON_ENUM]
+      @finish_reason = finish_reason
+      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @additional_properties = additional_properties
+    end
+
+    # Deserialize a JSON object to an instance of FulfilledPromptExecutionMeta
+    #
+    # @param json_object [JSON]
+    # @return [FulfilledPromptExecutionMeta]
+    def self.from_json(json_object:)
+      struct = JSON.parse(json_object, object_class: OpenStruct)
+      parsed_json = JSON.parse(json_object)
+      latency = struct.latency
+      finish_reason = FINISH_REASON_ENUM.key(parsed_json["finish_reason"]) || parsed_json["finish_reason"]
+      new(latency: latency, finish_reason: finish_reason, additional_properties: struct)
+    end
+
+    # Serialize an instance of FulfilledPromptExecutionMeta to a JSON object
+    #
+    # @return [JSON]
+    def to_json(*_args)
+      { "latency": @latency, "finish_reason": FINISH_REASON_ENUM[@finish_reason] || @finish_reason }.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.latency&.is_a?(Integer) != false || raise("Passed value for field obj.latency 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.")
+    end
+  end
+end