assemblyai 1.0.0.pre.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bc0caf7b84497b13453af130bf9ed562274853b8a40c27c84dbe0e485271f099
+  data.tar.gz: fa25a137746aeb43fd13427e7e8c7de382b0a6684744fa7c805f32b2c9ffcc45
+SHA512:
+  metadata.gz: 3e6c4c159194b38ed20d04228f253892ec24a4a4550a6ad1f29601a790689d833d5b608a5d8ba19a0fa8cf6585a8af1c5039a62f32d3b3c8664f2aceba68c2cf
+  data.tar.gz: 5bffb7383c0b3e0e7ff9c9128c3022db428746beed340222157c49cf6b993f95d1a7cd60e93843cbfd3cd17ff6c4e9e3029b10fb4746a2d5adbe099077eda58f

data/lib/assemblyai/files/client.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../../requests"
+require_relative "types/uploaded_file"
+require "async"
+
+module AssemblyAI
+  class FilesClient
+    attr_reader :request_client
+
+    # @param request_client [RequestClient]
+    # @return [FilesClient]
+    def initialize(request_client:)
+      # @type [RequestClient]
+      @request_client = request_client
+    end
+
+    # Upload your media file directly to the AssemblyAI API if it isn't accessible via a URL already.
+    #
+    # @param request [String] Base64 encoded bytes
+    # @param request_options [RequestOptions]
+    # @return [Files::UploadedFile]
+    def upload(request:, request_options: nil)
+      response = @request_client.conn.post("/v2/upload") do |req|
+        req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+        req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+        req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        req.headers["Content-Type"] = "application/octet-stream"
+        req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+      end
+      Files::UploadedFile.from_json(json_object: response.body)
+    end
+  end
+
+  class AsyncFilesClient
+    attr_reader :request_client
+
+    # @param request_client [AsyncRequestClient]
+    # @return [AsyncFilesClient]
+    def initialize(request_client:)
+      # @type [AsyncRequestClient]
+      @request_client = request_client
+    end
+
+    # Upload your media file directly to the AssemblyAI API if it isn't accessible via a URL already.
+    #
+    # @param request [String] Base64 encoded bytes
+    # @param request_options [RequestOptions]
+    # @return [Files::UploadedFile]
+    def upload(request:, request_options: nil)
+      Async do
+        response = @request_client.conn.post("/v2/upload") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.headers["Content-Type"] = "application/octet-stream"
+          req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+        end
+        Files::UploadedFile.from_json(json_object: response.body)
+      end
+    end
+  end
+end

data/lib/assemblyai/files/types/uploaded_file.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "json"
+
+module AssemblyAI
+  class Files
+    class UploadedFile
+      attr_reader :upload_url, :additional_properties
+
+      # @param upload_url [String] A URL that points to your audio file, accessible only by AssemblyAI's servers
+      # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+      # @return [Files::UploadedFile]
+      def initialize(upload_url:, additional_properties: nil)
+        # @type [String] A URL that points to your audio file, accessible only by AssemblyAI's servers
+        @upload_url = upload_url
+        # @type [OpenStruct] Additional properties unmapped to the current class definition
+        @additional_properties = additional_properties
+      end
+
+      # Deserialize a JSON object to an instance of UploadedFile
+      #
+      # @param json_object [JSON]
+      # @return [Files::UploadedFile]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        JSON.parse(json_object)
+        upload_url = struct.upload_url
+        new(upload_url: upload_url, additional_properties: struct)
+      end
+
+      # Serialize an instance of UploadedFile to a JSON object
+      #
+      # @return [JSON]
+      def to_json(*_args)
+        { "upload_url": @upload_url }.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.upload_url.is_a?(String) != false || raise("Passed value for field obj.upload_url is not the expected type, validation failed.")
+      end
+    end
+  end
+end

data/lib/assemblyai/lemur/client.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+require_relative "../../requests"
+require_relative "types/lemur_base_params_context"
+require_relative "types/lemur_model"
+require_relative "types/lemur_task_response"
+require_relative "types/lemur_summary_response"
+require_relative "types/lemur_question"
+require_relative "types/lemur_question_answer_response"
+require_relative "types/lemur_action_items_response"
+require_relative "types/purge_lemur_request_data_response"
+require "async"
+
+module AssemblyAI
+  class LemurClient
+    attr_reader :request_client
+
+    # @param request_client [RequestClient]
+    # @return [LemurClient]
+    def initialize(request_client:)
+      # @type [RequestClient]
+      @request_client = request_client
+    end
+
+    # Use the LeMUR task endpoint to input your own LLM prompt.
+    #
+    # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param context [Hash] Context to provide the model. This can be a string or a free-form JSON value.Request of type Lemur::LemurBaseParamsContext, as a Hash
+    # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+    #   Defaults to "default".
+    # @param max_output_size [Integer] Max output size in tokens, up to 4000
+    # @param temperature [Float] The temperature to use for the model.
+    #   Higher values result in answers that are more creative, lower values are more conservative.
+    #   Can be any value between 0.0 and 1.0 inclusive.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @param prompt [String] Your text to prompt the model to produce a desired output, including any context you want to pass into the model.
+    # @param request_options [RequestOptions]
+    # @return [Lemur::LemurTaskResponse]
+    def task(prompt:, transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+             temperature: nil, additional_properties: nil, request_options: nil)
+      response = @request_client.conn.post("/lemur/v3/generate/task") do |req|
+        req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+        req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+        req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        req.body = {
+          **(request_options&.additional_body_parameters || {}),
+          transcript_ids: transcript_ids,
+          input_text: input_text,
+          context: context,
+          final_model: final_model,
+          max_output_size: max_output_size,
+          temperature: temperature,
+          additional_properties: additional_properties,
+          prompt: prompt
+        }.compact
+      end
+      Lemur::LemurTaskResponse.from_json(json_object: response.body)
+    end
+
+    # Custom Summary allows you to distill a piece of audio into a few impactful sentences. You can give the model context to obtain more targeted results while outputting the results in a variety of formats described in human language.
+    #
+    # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param context [Hash] Context to provide the model. This can be a string or a free-form JSON value.Request of type Lemur::LemurBaseParamsContext, as a Hash
+    # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+    #   Defaults to "default".
+    # @param max_output_size [Integer] Max output size in tokens, up to 4000
+    # @param temperature [Float] The temperature to use for the model.
+    #   Higher values result in answers that are more creative, lower values are more conservative.
+    #   Can be any value between 0.0 and 1.0 inclusive.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @param answer_format [String] How you want the summary to be returned. This can be any text. Examples: "TLDR", "bullet points"
+    # @param request_options [RequestOptions]
+    # @return [Lemur::LemurSummaryResponse]
+    def summary(transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+                temperature: nil, additional_properties: nil, answer_format: nil, request_options: nil)
+      response = @request_client.conn.post("/lemur/v3/generate/summary") do |req|
+        req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+        req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+        req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        req.body = {
+          **(request_options&.additional_body_parameters || {}),
+          transcript_ids: transcript_ids,
+          input_text: input_text,
+          context: context,
+          final_model: final_model,
+          max_output_size: max_output_size,
+          temperature: temperature,
+          additional_properties: additional_properties,
+          answer_format: answer_format
+        }.compact
+      end
+      Lemur::LemurSummaryResponse.from_json(json_object: response.body)
+    end
+
+    # Question & Answer allows you to ask free-form questions about a single transcript or a group of transcripts. The questions can be any whose answers you find useful, such as judging whether a caller is likely to become a customer or whether all items on a meeting's agenda were covered.
+    #
+    # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param context [Hash] Context to provide the model. This can be a string or a free-form JSON value.Request of type Lemur::LemurBaseParamsContext, as a Hash
+    # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+    #   Defaults to "default".
+    # @param max_output_size [Integer] Max output size in tokens, up to 4000
+    # @param temperature [Float] The temperature to use for the model.
+    #   Higher values result in answers that are more creative, lower values are more conservative.
+    #   Can be any value between 0.0 and 1.0 inclusive.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @param questions [Array<Hash>] A list of questions to askRequest of type Array<Lemur::LemurQuestion>, as a Hash
+    #   * :question (String)
+    #   * :context (Hash)
+    #   * :answer_format (String)
+    #   * :answer_options (Array<String>)
+    # @param request_options [RequestOptions]
+    # @return [Lemur::LemurQuestionAnswerResponse]
+    def question_answer(questions:, transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+                        temperature: nil, additional_properties: nil, request_options: nil)
+      response = @request_client.conn.post("/lemur/v3/generate/question-answer") do |req|
+        req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+        req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+        req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        req.body = {
+          **(request_options&.additional_body_parameters || {}),
+          transcript_ids: transcript_ids,
+          input_text: input_text,
+          context: context,
+          final_model: final_model,
+          max_output_size: max_output_size,
+          temperature: temperature,
+          additional_properties: additional_properties,
+          questions: questions
+        }.compact
+      end
+      Lemur::LemurQuestionAnswerResponse.from_json(json_object: response.body)
+    end
+
+    # Use LeMUR to generate a list of action items from a transcript
+    #
+    # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param context [Hash] Context to provide the model. This can be a string or a free-form JSON value.Request of type Lemur::LemurBaseParamsContext, as a Hash
+    # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+    #   Defaults to "default".
+    # @param max_output_size [Integer] Max output size in tokens, up to 4000
+    # @param temperature [Float] The temperature to use for the model.
+    #   Higher values result in answers that are more creative, lower values are more conservative.
+    #   Can be any value between 0.0 and 1.0 inclusive.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @param answer_format [String] How you want the action items to be returned. This can be any text.
+    #   Defaults to "Bullet Points".
+    # @param request_options [RequestOptions]
+    # @return [Lemur::LemurActionItemsResponse]
+    def action_items(transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+                     temperature: nil, additional_properties: nil, answer_format: nil, request_options: nil)
+      response = @request_client.conn.post("/lemur/v3/generate/action-items") do |req|
+        req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+        req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+        req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        req.body = {
+          **(request_options&.additional_body_parameters || {}),
+          transcript_ids: transcript_ids,
+          input_text: input_text,
+          context: context,
+          final_model: final_model,
+          max_output_size: max_output_size,
+          temperature: temperature,
+          additional_properties: additional_properties,
+          answer_format: answer_format
+        }.compact
+      end
+      Lemur::LemurActionItemsResponse.from_json(json_object: response.body)
+    end
+
+    # Delete the data for a previously submitted LeMUR request.
+    # The LLM response data, as well as any context provided in the original request will be removed.
+    #
+    # @param request_id [String] The ID of the LeMUR request whose data you want to delete. This would be found in the response of the original request.
+    # @param request_options [RequestOptions]
+    # @return [Lemur::PurgeLemurRequestDataResponse]
+    def purge_request_data(request_id:, request_options: nil)
+      response = @request_client.conn.delete("/lemur/v3/#{request_id}") do |req|
+        req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+        req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+        req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+      end
+      Lemur::PurgeLemurRequestDataResponse.from_json(json_object: response.body)
+    end
+  end
+
+  class AsyncLemurClient
+    attr_reader :request_client
+
+    # @param request_client [AsyncRequestClient]
+    # @return [AsyncLemurClient]
+    def initialize(request_client:)
+      # @type [AsyncRequestClient]
+      @request_client = request_client
+    end
+
+    # Use the LeMUR task endpoint to input your own LLM prompt.
+    #
+    # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param context [Hash] Context to provide the model. This can be a string or a free-form JSON value.Request of type Lemur::LemurBaseParamsContext, as a Hash
+    # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+    #   Defaults to "default".
+    # @param max_output_size [Integer] Max output size in tokens, up to 4000
+    # @param temperature [Float] The temperature to use for the model.
+    #   Higher values result in answers that are more creative, lower values are more conservative.
+    #   Can be any value between 0.0 and 1.0 inclusive.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @param prompt [String] Your text to prompt the model to produce a desired output, including any context you want to pass into the model.
+    # @param request_options [RequestOptions]
+    # @return [Lemur::LemurTaskResponse]
+    def task(prompt:, transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+             temperature: nil, additional_properties: nil, request_options: nil)
+      Async do
+        response = @request_client.conn.post("/lemur/v3/generate/task") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.body = {
+            **(request_options&.additional_body_parameters || {}),
+            transcript_ids: transcript_ids,
+            input_text: input_text,
+            context: context,
+            final_model: final_model,
+            max_output_size: max_output_size,
+            temperature: temperature,
+            additional_properties: additional_properties,
+            prompt: prompt
+          }.compact
+        end
+        Lemur::LemurTaskResponse.from_json(json_object: response.body)
+      end
+    end
+
+    # Custom Summary allows you to distill a piece of audio into a few impactful sentences. You can give the model context to obtain more targeted results while outputting the results in a variety of formats described in human language.
+    #
+    # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param context [Hash] Context to provide the model. This can be a string or a free-form JSON value.Request of type Lemur::LemurBaseParamsContext, as a Hash
+    # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+    #   Defaults to "default".
+    # @param max_output_size [Integer] Max output size in tokens, up to 4000
+    # @param temperature [Float] The temperature to use for the model.
+    #   Higher values result in answers that are more creative, lower values are more conservative.
+    #   Can be any value between 0.0 and 1.0 inclusive.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @param answer_format [String] How you want the summary to be returned. This can be any text. Examples: "TLDR", "bullet points"
+    # @param request_options [RequestOptions]
+    # @return [Lemur::LemurSummaryResponse]
+    def summary(transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+                temperature: nil, additional_properties: nil, answer_format: nil, request_options: nil)
+      Async do
+        response = @request_client.conn.post("/lemur/v3/generate/summary") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.body = {
+            **(request_options&.additional_body_parameters || {}),
+            transcript_ids: transcript_ids,
+            input_text: input_text,
+            context: context,
+            final_model: final_model,
+            max_output_size: max_output_size,
+            temperature: temperature,
+            additional_properties: additional_properties,
+            answer_format: answer_format
+          }.compact
+        end
+        Lemur::LemurSummaryResponse.from_json(json_object: response.body)
+      end
+    end
+
+    # Question & Answer allows you to ask free-form questions about a single transcript or a group of transcripts. The questions can be any whose answers you find useful, such as judging whether a caller is likely to become a customer or whether all items on a meeting's agenda were covered.
+    #
+    # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param context [Hash] Context to provide the model. This can be a string or a free-form JSON value.Request of type Lemur::LemurBaseParamsContext, as a Hash
+    # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+    #   Defaults to "default".
+    # @param max_output_size [Integer] Max output size in tokens, up to 4000
+    # @param temperature [Float] The temperature to use for the model.
+    #   Higher values result in answers that are more creative, lower values are more conservative.
+    #   Can be any value between 0.0 and 1.0 inclusive.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @param questions [Array<Hash>] A list of questions to askRequest of type Array<Lemur::LemurQuestion>, as a Hash
+    #   * :question (String)
+    #   * :context (Hash)
+    #   * :answer_format (String)
+    #   * :answer_options (Array<String>)
+    # @param request_options [RequestOptions]
+    # @return [Lemur::LemurQuestionAnswerResponse]
+    def question_answer(questions:, transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+                        temperature: nil, additional_properties: nil, request_options: nil)
+      Async do
+        response = @request_client.conn.post("/lemur/v3/generate/question-answer") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.body = {
+            **(request_options&.additional_body_parameters || {}),
+            transcript_ids: transcript_ids,
+            input_text: input_text,
+            context: context,
+            final_model: final_model,
+            max_output_size: max_output_size,
+            temperature: temperature,
+            additional_properties: additional_properties,
+            questions: questions
+          }.compact
+        end
+        Lemur::LemurQuestionAnswerResponse.from_json(json_object: response.body)
+      end
+    end
+
+    # Use LeMUR to generate a list of action items from a transcript
+    #
+    # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+    #   Use either transcript_ids or input_text as input into LeMUR.
+    # @param context [Hash] Context to provide the model. This can be a string or a free-form JSON value.Request of type Lemur::LemurBaseParamsContext, as a Hash
+    # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+    #   Defaults to "default".
+    # @param max_output_size [Integer] Max output size in tokens, up to 4000
+    # @param temperature [Float] The temperature to use for the model.
+    #   Higher values result in answers that are more creative, lower values are more conservative.
+    #   Can be any value between 0.0 and 1.0 inclusive.
+    # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+    # @param answer_format [String] How you want the action items to be returned. This can be any text.
+    #   Defaults to "Bullet Points".
+    # @param request_options [RequestOptions]
+    # @return [Lemur::LemurActionItemsResponse]
+    def action_items(transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+                     temperature: nil, additional_properties: nil, answer_format: nil, request_options: nil)
+      Async do
+        response = @request_client.conn.post("/lemur/v3/generate/action-items") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+          req.body = {
+            **(request_options&.additional_body_parameters || {}),
+            transcript_ids: transcript_ids,
+            input_text: input_text,
+            context: context,
+            final_model: final_model,
+            max_output_size: max_output_size,
+            temperature: temperature,
+            additional_properties: additional_properties,
+            answer_format: answer_format
+          }.compact
+        end
+        Lemur::LemurActionItemsResponse.from_json(json_object: response.body)
+      end
+    end
+
+    # Delete the data for a previously submitted LeMUR request.
+    # The LLM response data, as well as any context provided in the original request will be removed.
+    #
+    # @param request_id [String] The ID of the LeMUR request whose data you want to delete. This would be found in the response of the original request.
+    # @param request_options [RequestOptions]
+    # @return [Lemur::PurgeLemurRequestDataResponse]
+    def purge_request_data(request_id:, request_options: nil)
+      Async do
+        response = @request_client.conn.delete("/lemur/v3/#{request_id}") do |req|
+          req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+          req.headers["Authorization"] = request_options.api_key unless request_options&.api_key.nil?
+          req.headers = { **req.headers, **(request_options&.additional_headers || {}) }.compact
+        end
+        Lemur::PurgeLemurRequestDataResponse.from_json(json_object: response.body)
+      end
+    end
+  end
+end

data/lib/assemblyai/lemur/types/lemur_action_items_response.rb

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

data/lib/assemblyai/lemur/types/lemur_base_params.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "lemur_base_params_context"
+require_relative "lemur_model"
+require "json"
+
+module AssemblyAI
+  class Lemur
+    class LemurBaseParams
+      attr_reader :transcript_ids, :input_text, :context, :final_model, :max_output_size, :temperature,
+                  :additional_properties
+
+      # @param transcript_ids [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+      #   Use either transcript_ids or input_text as input into LeMUR.
+      # @param input_text [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+      #   Use either transcript_ids or input_text as input into LeMUR.
+      # @param context [Lemur::LemurBaseParamsContext] Context to provide the model. This can be a string or a free-form JSON value.
+      # @param final_model [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+      #   Defaults to "default".
+      # @param max_output_size [Integer] Max output size in tokens, up to 4000
+      # @param temperature [Float] The temperature to use for the model.
+      #   Higher values result in answers that are more creative, lower values are more conservative.
+      #   Can be any value between 0.0 and 1.0 inclusive.
+      # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+      # @return [Lemur::LemurBaseParams]
+      def initialize(transcript_ids: nil, input_text: nil, context: nil, final_model: nil, max_output_size: nil,
+                     temperature: nil, additional_properties: nil)
+        # @type [Array<String>] A list of completed transcripts with text. Up to a maximum of 100 files or 100 hours, whichever is lower.
+        #   Use either transcript_ids or input_text as input into LeMUR.
+        @transcript_ids = transcript_ids
+        # @type [String] Custom formatted transcript data. Maximum size is the context limit of the selected model, which defaults to 100000.
+        #   Use either transcript_ids or input_text as input into LeMUR.
+        @input_text = input_text
+        # @type [Lemur::LemurBaseParamsContext] Context to provide the model. This can be a string or a free-form JSON value.
+        @context = context
+        # @type [LEMUR_MODEL] The model that is used for the final prompt after compression is performed.
+        #   Defaults to "default".
+        @final_model = final_model
+        # @type [Integer] Max output size in tokens, up to 4000
+        @max_output_size = max_output_size
+        # @type [Float] The temperature to use for the model.
+        #   Higher values result in answers that are more creative, lower values are more conservative.
+        #   Can be any value between 0.0 and 1.0 inclusive.
+        @temperature = temperature
+        # @type [OpenStruct] Additional properties unmapped to the current class definition
+        @additional_properties = additional_properties
+      end
+
+      # Deserialize a JSON object to an instance of LemurBaseParams
+      #
+      # @param json_object [JSON]
+      # @return [Lemur::LemurBaseParams]
+      def self.from_json(json_object:)
+        struct = JSON.parse(json_object, object_class: OpenStruct)
+        parsed_json = JSON.parse(json_object)
+        transcript_ids = struct.transcript_ids
+        input_text = struct.input_text
+        if parsed_json["context"].nil?
+          context = nil
+        else
+          context = parsed_json["context"].to_json
+          context = Lemur::LemurBaseParamsContext.from_json(json_object: context)
+        end
+        final_model = Lemur::LEMUR_MODEL.key(parsed_json["final_model"]) || parsed_json["final_model"]
+        max_output_size = struct.max_output_size
+        temperature = struct.temperature
+        new(transcript_ids: transcript_ids, input_text: input_text, context: context, final_model: final_model,
+            max_output_size: max_output_size, temperature: temperature, additional_properties: struct)
+      end
+
+      # Serialize an instance of LemurBaseParams to a JSON object
+      #
+      # @return [JSON]
+      def to_json(*_args)
+        {
+          "transcript_ids": @transcript_ids,
+          "input_text": @input_text,
+          "context": @context,
+          "final_model": Lemur::LEMUR_MODEL[@final_model] || @final_model,
+          "max_output_size": @max_output_size,
+          "temperature": @temperature
+        }.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.transcript_ids&.is_a?(Array) != false || raise("Passed value for field obj.transcript_ids is not the expected type, validation failed.")
+        obj.input_text&.is_a?(String) != false || raise("Passed value for field obj.input_text is not the expected type, validation failed.")
+        obj.context.nil? || Lemur::LemurBaseParamsContext.validate_raw(obj: obj.context)
+        obj.final_model&.is_a?(Lemur::LEMUR_MODEL) != false || raise("Passed value for field obj.final_model is not the expected type, validation failed.")
+        obj.max_output_size&.is_a?(Integer) != false || raise("Passed value for field obj.max_output_size is not the expected type, validation failed.")
+        obj.temperature&.is_a?(Float) != false || raise("Passed value for field obj.temperature is not the expected type, validation failed.")
+      end
+    end
+  end
+end