eleven_rb 0.4.0 → 1.1.0

data/lib/eleven_rb/objects/voice_settings.rb

@@ -25,6 +25,39 @@ module ElevenRb
         from_response(DEFAULTS.merge(overrides))
       end
 
+      # Voice-setting keys the capability table knows about. Only these can be
+      # dropped for a model; any other key is passed through untouched so a
+      # future API field is never swallowed.
+      KNOWN_KEYS = ModelCapabilities::ALL_VOICE_SETTINGS
+
+      # Build the voice_settings hash a model actually honours
+      #
+      # Starts from DEFAULTS filtered to the model's supported keys and merges the
+      # overrides (keys symbolized). Known keys the model does not support are
+      # dropped; unknown keys pass through after the supported ones, in the
+      # caller's order; nil values are removed. Only non-nil override keys count
+      # as dropped: defaults the model does not take are filtered silently.
+      #
+      # @example
+      #   VoiceSettings.for_model('eleven_multilingual_v2')
+      #   # => [{ stability: 0.5, similarity_boost: 0.75, style: 0.0, use_speaker_boost: true }, []]
+      #   VoiceSettings.for_model('eleven_v4', speed: 1.1)
+      #   # => [{ stability: 0.5, similarity_boost: 0.75 }, [:speed]]
+      #
+      # @param model_id [String] the model ID
+      # @param overrides [Hash] caller settings (String or Symbol keys)
+      # @return [Array(Hash, Array<Symbol>)] the settings hash and the dropped override keys
+      def self.for_model(model_id, overrides = {})
+        supported = ModelCapabilities.supported_voice_settings(model_id)
+        requested = (overrides || {}).to_h.transform_keys(&:to_sym)
+
+        dropped = requested.compact.keys & (KNOWN_KEYS - supported)
+        unknown = requested.except(*KNOWN_KEYS)
+        settings = DEFAULTS.slice(*supported).merge(requested.slice(*supported)).merge(unknown).compact
+
+        [settings, dropped]
+      end
+
       # Convert to hash suitable for API request
       #
       # @return [Hash]

data/lib/eleven_rb/resources/base.rb

@@ -51,6 +51,24 @@ module ElevenRb
         http_client.post(path, body, response_type: :binary)
       end
 
+      # Make a JSON POST request and also return the response headers
+      #
+      # @param path [String]
+      # @param body [Hash]
+      # @return [Hash] `{ body: Hash, headers: Hash<String, String> }`
+      def post_with_meta(path, body = {})
+        http_client.post(path, body, response_type: :json, with_meta: true)
+      end
+
+      # Make a binary POST request and also return the response headers
+      #
+      # @param path [String]
+      # @param body [Hash]
+      # @return [Hash] `{ body: String, headers: Hash<String, String> }`
+      def post_binary_with_meta(path, body = {})
+        http_client.post(path, body, response_type: :binary, with_meta: true)
+      end
+
       # Make a streaming POST request
       #
       # @param path [String]

data/lib/eleven_rb/resources/models.rb

@@ -9,23 +9,36 @@ module ElevenRb
     #
     # @example Find multilingual models
     #   client.models.multilingual
+    #
+    # @example Find one model
+    #   client.models.find('eleven_v4')
     class Models < Base
       # List all available models
       #
       # @return [Array<Objects::Model>]
       def list
-        response = get('/models')
+        # Call the HTTP client directly: #get below is the model lookup (kept for
+        # compatibility) and shadows Base#get, which made this method recurse.
+        response = http_client.get('/models')
         response.map { |m| Objects::Model.from_response(m) }
       end
 
-      # Get a specific model by ID
+      # Find a specific model by ID
       #
       # @param model_id [String] the model ID
       # @return [Objects::Model, nil]
-      def get(model_id)
+      def find(model_id)
         list.find { |m| m.model_id == model_id }
       end
 
+      # Alias of {#find}, kept for backwards compatibility
+      #
+      # @param model_id [String] the model ID
+      # @return [Objects::Model, nil]
+      def get(model_id)
+        find(model_id)
+      end
+
       # Get all multilingual models
       #
       # @return [Array<Objects::Model>]
@@ -51,7 +64,20 @@ module ElevenRb
       #
       # @return [Objects::Model, nil]
       def default
-        get('eleven_multilingual_v2') || tts_capable.first
+        default_from(list)
+      end
+
+      # Get the latest/most capable model available to the account:
+      # eleven_v4, else eleven_v3, else {#default} (one /models request)
+      #
+      # @return [Objects::Model, nil]
+      def latest
+        models = list
+        %w[eleven_v4 eleven_v3].each do |model_id|
+          model = models.find { |m| m.model_id == model_id }
+          return model if model
+        end
+        default_from(models)
       end
 
       # Get model IDs as array
@@ -60,6 +86,13 @@ module ElevenRb
       def ids
         list.map(&:model_id)
       end
+
+      private
+
+      # eleven_multilingual_v2, else the first TTS-capable model, from an already-fetched list
+      def default_from(models)
+        models.find { |m| m.model_id == 'eleven_multilingual_v2' } || models.find(&:can_do_text_to_speech)
+      end
     end
   end
 end

data/lib/eleven_rb/resources/text_to_dialogue.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module ElevenRb
+  module Resources
+    # Text-to-dialogue resource for multi-speaker audio generation
+    #
+    # @example Generate dialogue
+    #   audio = client.text_to_dialogue.generate([
+    #     { text: "[excited] Welcome!", voice_id: "voice_abc" },
+    #     { text: "[laughs] Thanks!", voice_id: "voice_xyz" }
+    #   ])
+    #   audio.save_to_file("dialogue.mp3")
+    #
+    # @example Dialogue with timestamps and per-speaker segments
+    #   result = client.dialogue.generate_with_timestamps(inputs, seed: 7)
+    #   result[:voice_segments] # => [{ "voice_id" => ..., "start_time_seconds" => ... }, ...]
+    class TextToDialogue < Base
+      DEFAULT_MODEL = 'eleven_v4'
+      MAX_VOICES_PER_REQUEST = 10
+
+      # Kept for compatibility. The hard cap now comes from
+      # ModelCapabilities.max_text_length(model_id) (5,000 for eleven_v3).
+      MAX_TEXT_LENGTH = 5000
+
+      # Above this many characters the API recommends splitting the dialogue;
+      # the gem logs a warning but still sends the request.
+      RECOMMENDED_MAX_TEXT_LENGTH = 2_000
+
+      # Optional request-body keys, in the order they are written to the body.
+      # Each is omitted from the body when nil.
+      OPTIONAL_BODY_KEYS = %i[
+        language_code
+        settings
+        seed
+        use_pvc_as_ivc
+        previous_text
+        future_text
+        previous_request_ids
+        next_request_ids
+        pronunciation_dictionary_locators
+      ].freeze
+
+      # Generate dialogue audio from multiple speaker inputs
+      #
+      # @param inputs [Array<Hash>] Array of { text:, voice_id: } hashes
+      # @param model_id [String] Model to use (default: eleven_v4)
+      # @param language_code [String, nil] ISO 639-1 language code
+      # @param settings [Hash, nil] Generation settings, sent unchanged (e.g. stability, similarity)
+      # @param seed [Integer, nil] Seed for reproducibility
+      # @param output_format [String] Audio output format
+      # @param apply_text_normalization [String] "auto", "on", or "off"
+      # @param use_pvc_as_ivc [Boolean, nil] use the IVC version of professional voices
+      # @param previous_text [String, nil] text that comes before this dialogue (continuity)
+      # @param future_text [String, nil] text that comes after this dialogue (continuity)
+      # @param previous_request_ids [Array<String>, nil] request IDs of preceding generations
+      # @param next_request_ids [Array<String>, nil] request IDs of following generations
+      # @param pronunciation_dictionary_locators [Array<Hash>, nil] pronunciation dictionaries to apply
+      # @return [Objects::Audio]
+      def generate(
+        inputs,
+        model_id: DEFAULT_MODEL,
+        language_code: nil,
+        settings: nil,
+        seed: nil,
+        output_format: 'mp3_44100_128',
+        apply_text_normalization: 'auto',
+        use_pvc_as_ivc: nil,
+        previous_text: nil,
+        future_text: nil,
+        previous_request_ids: nil,
+        next_request_ids: nil,
+        pronunciation_dictionary_locators: nil
+      )
+        validate_inputs!(inputs, model_id)
+
+        body = build_request_body(inputs, model_id, apply_text_normalization, optional_values(binding))
+        response = post_binary_with_meta("/text-to-dialogue?output_format=#{output_format}", body)
+
+        build_audio_response(response[:body], inputs, output_format, model_id,
+                             request_id: response[:headers]['request-id'])
+      end
+
+      # Generate dialogue audio with character timestamps and per-voice segments
+      #
+      # Takes the same keywords as {#generate}.
+      #
+      # @param inputs [Array<Hash>] Array of { text:, voice_id: } hashes
+      # @return [Hash] `{ audio:, alignment:, normalized_alignment:, voice_segments:, request_id: }`
+      def generate_with_timestamps(
+        inputs,
+        model_id: DEFAULT_MODEL,
+        language_code: nil,
+        settings: nil,
+        seed: nil,
+        output_format: 'mp3_44100_128',
+        apply_text_normalization: 'auto',
+        use_pvc_as_ivc: nil,
+        previous_text: nil,
+        future_text: nil,
+        previous_request_ids: nil,
+        next_request_ids: nil,
+        pronunciation_dictionary_locators: nil
+      )
+        validate_inputs!(inputs, model_id)
+
+        body = build_request_body(inputs, model_id, apply_text_normalization, optional_values(binding))
+        result = post_with_meta("/text-to-dialogue/with-timestamps?output_format=#{output_format}", body)
+        response = result[:body]
+        request_id = result[:headers]['request-id']
+
+        audio_data = Base64.decode64(response['audio_base64']) if response['audio_base64']
+        audio = (build_audio_response(audio_data, inputs, output_format, model_id, request_id: request_id) if audio_data)
+
+        {
+          audio: audio,
+          alignment: response['alignment'],
+          normalized_alignment: response['normalized_alignment'],
+          voice_segments: response['voice_segments'],
+          request_id: request_id
+        }
+      end
+
+      private
+
+      # The optional keyword values of the calling method, keyed by OPTIONAL_BODY_KEYS
+      def optional_values(caller_binding)
+        OPTIONAL_BODY_KEYS.to_h { |key| [key, caller_binding.local_variable_get(key)] }
+      end
+
+      def build_request_body(inputs, model_id, apply_text_normalization, options)
+        body = {
+          inputs: inputs.map { |i| { text: i[:text], voice_id: i[:voice_id] } },
+          model_id: model_id,
+          apply_text_normalization: apply_text_normalization
+        }
+
+        OPTIONAL_BODY_KEYS.each do |key|
+          body[key] = options[key] unless options[key].nil?
+        end
+        body
+      end
+
+      def build_audio_response(data, inputs, output_format, model_id, request_id: nil)
+        total_text = inputs.map { |i| i[:text] }.join("\n")
+        total_chars = inputs.sum { |i| i[:text].length }
+        primary_voice = inputs.first[:voice_id]
+
+        audio = Objects::Audio.new(
+          data: data, format: output_format,
+          voice_id: primary_voice, text: total_text, model_id: model_id,
+          request_id: request_id
+        )
+
+        cost_info = Objects::CostInfo.new(
+          character_count: total_chars, voice_id: primary_voice, model_id: model_id
+        )
+
+        http_client.config.trigger(
+          :on_audio_generated,
+          audio: audio, voice_id: primary_voice,
+          text: total_text, cost_info: cost_info.to_h,
+          request_id: request_id
+        )
+
+        audio
+      end
+
+      def validate_inputs!(inputs, model_id = DEFAULT_MODEL)
+        raise Errors::ValidationError, 'inputs must be a non-empty array' unless inputs.is_a?(Array) && !inputs.empty?
+
+        inputs.each_with_index do |input, i|
+          validate_presence!(input[:text], "inputs[#{i}].text")
+          validate_presence!(input[:voice_id], "inputs[#{i}].voice_id")
+        end
+
+        unique_voices = inputs.map { |i| i[:voice_id] }.uniq
+        if unique_voices.length > MAX_VOICES_PER_REQUEST
+          raise Errors::ValidationError,
+                "Maximum #{MAX_VOICES_PER_REQUEST} unique voices per request " \
+                "(got #{unique_voices.length})"
+        end
+
+        validate_text_length!(inputs.sum { |i| i[:text].length }, model_id)
+      end
+
+      def validate_text_length!(total_chars, model_id)
+        max_length = ModelCapabilities.max_text_length(model_id)
+        if total_chars > max_length
+          raise Errors::ValidationError,
+                "Total text length #{total_chars} exceeds maximum " \
+                "#{max_length} characters for #{model_id}"
+        end
+
+        return unless total_chars > RECOMMENDED_MAX_TEXT_LENGTH
+
+        http_client.config.logger&.warn(
+          "[ElevenRb] text-to-dialogue text is #{total_chars} characters; " \
+          "#{RECOMMENDED_MAX_TEXT_LENGTH} or fewer per request is recommended"
+        )
+      end
+    end
+  end
+end

data/lib/eleven_rb/resources/text_to_speech.rb

@@ -12,18 +12,67 @@ module ElevenRb
     #   client.tts.stream("Hello world", voice_id: "voice_id") do |chunk|
     #     io.write(chunk)
     #   end
+    #
+    # @example Eleven v4 with continuity and a fixed seed
+    #   audio = client.tts.generate(
+    #     "[sighs] Right. Let's try that again.",
+    #     voice_id: "voice_id",
+    #     model_id: "eleven_v4",
+    #     seed: 42,
+    #     previous_text: "That did not go to plan."
+    #   )
+    #   audio.request_id # => "abc123" (from the request-id response header)
     class TextToSpeech < Base
       DEFAULT_MODEL = 'eleven_multilingual_v2'
+
+      # Kept for compatibility. The per-request cap now comes from
+      # ModelCapabilities.max_text_length(model_id) (5,000 for eleven_v3).
       MAX_TEXT_LENGTH = 5000
 
+      # Output formats the API accepts (documentation only; not validated)
       OUTPUT_FORMATS = %w[
+        mp3_22050_32
+        mp3_24000_48
+        mp3_44100_32
+        mp3_44100_64
+        mp3_44100_96
         mp3_44100_128
         mp3_44100_192
+        opus_48000_32
+        opus_48000_64
+        opus_48000_96
+        opus_48000_128
+        opus_48000_192
+        pcm_8000
         pcm_16000
         pcm_22050
         pcm_24000
+        pcm_32000
         pcm_44100
+        pcm_48000
+        wav_8000
+        wav_16000
+        wav_22050
+        wav_24000
+        wav_32000
+        wav_44100
+        wav_48000
         ulaw_8000
+        alaw_8000
+      ].freeze
+
+      # Optional request-body keys, in the order they are written to the body.
+      # Each is omitted from the body when nil.
+      OPTIONAL_BODY_KEYS = %i[
+        language_code
+        apply_text_normalization
+        seed
+        previous_text
+        next_text
+        previous_request_ids
+        next_request_ids
+        pronunciation_dictionary_locators
+        use_pvc_as_ivc
       ].freeze
 
       # Generate audio from text
@@ -31,30 +80,39 @@ module ElevenRb
       # @param text [String] the text to convert
       # @param voice_id [String] the voice ID to use
       # @param model_id [String] the model to use (default: eleven_multilingual_v2)
-      # @param voice_settings [Hash] voice settings overrides
+      # @param voice_settings [Hash] voice settings overrides (keys the model ignores are dropped)
       # @param output_format [String] audio output format
-      # @return [Objects::Audio]
-      def generate(text, voice_id:, model_id: DEFAULT_MODEL, voice_settings: {}, output_format: 'mp3_44100_128')
-        validate_text!(text)
+      # @param language_code [String, nil] ISO 639-1 language code to enforce
+      # @param apply_text_normalization [String, nil] "auto", "on" or "off"
+      # @param seed [Integer, nil] seed for reproducible generation
+      # @param previous_text [String, nil] text that comes before this request (continuity)
+      # @param next_text [String, nil] text that comes after this request (continuity)
+      # @param previous_request_ids [Array<String>, nil] request IDs of preceding generations
+      # @param next_request_ids [Array<String>, nil] request IDs of following generations
+      # @param pronunciation_dictionary_locators [Array<Hash>, nil] `{ pronunciation_dictionary_id:, version_id: }`
+      # @param use_pvc_as_ivc [Boolean, nil] use the IVC version of a professional voice
+      # @return [Objects::Audio] with request_id, character_cost and dropped_settings
+      def generate(text, voice_id:, model_id: DEFAULT_MODEL, voice_settings: {}, output_format: 'mp3_44100_128',
+                   language_code: nil, apply_text_normalization: nil, seed: nil, previous_text: nil,
+                   next_text: nil, previous_request_ids: nil, next_request_ids: nil,
+                   pronunciation_dictionary_locators: nil, use_pvc_as_ivc: nil)
+        validate_text!(text, model_id)
         validate_presence!(voice_id, 'voice_id')
-
-        settings = Objects::VoiceSettings::DEFAULTS.merge(voice_settings)
-
-        body = {
-          text: text,
-          model_id: model_id,
-          voice_settings: settings
-        }
+        body, dropped = build_body(text, model_id, voice_settings, optional_values(binding))
 
         path = "/text-to-speech/#{voice_id}?output_format=#{output_format}"
-        response = post_binary(path, body)
+        response = post_binary_with_meta(path, body)
+        headers = response[:headers]
 
         audio = Objects::Audio.new(
-          data: response,
+          data: response[:body],
           format: output_format,
           voice_id: voice_id,
           text: text,
-          model_id: model_id
+          model_id: model_id,
+          request_id: headers['request-id'],
+          character_cost: integer_header(headers, 'character-cost'),
+          dropped_settings: dropped
         )
 
         # Trigger cost tracking callback
@@ -64,7 +122,8 @@ module ElevenRb
           audio: audio,
           voice_id: voice_id,
           text: text,
-          cost_info: cost_info.to_h
+          cost_info: cost_info.to_h,
+          request_id: audio.request_id
         )
 
         audio
@@ -72,6 +131,8 @@ module ElevenRb
 
       # Stream audio from text
       #
+      # Takes the same optional keywords as {#generate}.
+      #
       # @param text [String] the text to convert
       # @param voice_id [String] the voice ID to use
       # @param model_id [String] the model to use
@@ -79,18 +140,15 @@ module ElevenRb
       # @param output_format [String] audio output format
       # @yield [String] each chunk of audio data
       # @return [void]
-      def stream(text, voice_id:, model_id: DEFAULT_MODEL, voice_settings: {}, output_format: 'mp3_44100_128', &block)
-        validate_text!(text)
+      def stream(text, voice_id:, model_id: DEFAULT_MODEL, voice_settings: {}, output_format: 'mp3_44100_128',
+                 language_code: nil, apply_text_normalization: nil, seed: nil, previous_text: nil,
+                 next_text: nil, previous_request_ids: nil, next_request_ids: nil,
+                 pronunciation_dictionary_locators: nil, use_pvc_as_ivc: nil, &block)
+        validate_text!(text, model_id)
         validate_presence!(voice_id, 'voice_id')
         raise ArgumentError, 'Block required for streaming' unless block_given?
 
-        settings = Objects::VoiceSettings::DEFAULTS.merge(voice_settings)
-
-        body = {
-          text: text,
-          model_id: model_id,
-          voice_settings: settings
-        }
+        body, = build_body(text, model_id, voice_settings, optional_values(binding))
 
         path = "/text-to-speech/#{voice_id}/stream?output_format=#{output_format}"
         post_stream(path, body, &block)
@@ -102,33 +160,35 @@ module ElevenRb
           audio: nil, # No audio object for streaming
           voice_id: voice_id,
           text: text,
-          cost_info: cost_info.to_h
+          cost_info: cost_info.to_h,
+          request_id: nil
         )
       end
 
       # Generate audio with timestamps
       #
+      # Takes the same optional keywords as {#generate}.
+      #
       # @param text [String] the text to convert
       # @param voice_id [String] the voice ID to use
       # @param model_id [String] the model to use
       # @param voice_settings [Hash] voice settings overrides
       # @param output_format [String] audio output format
-      # @return [Hash] contains :audio and :alignment data
+      # @return [Hash] `{ audio:, alignment:, normalized_alignment:, request_id:, character_cost: }`
       def generate_with_timestamps(text, voice_id:, model_id: DEFAULT_MODEL, voice_settings: {},
-                                   output_format: 'mp3_44100_128')
-        validate_text!(text)
+                                   output_format: 'mp3_44100_128', language_code: nil,
+                                   apply_text_normalization: nil, seed: nil, previous_text: nil,
+                                   next_text: nil, previous_request_ids: nil, next_request_ids: nil,
+                                   pronunciation_dictionary_locators: nil, use_pvc_as_ivc: nil)
+        validate_text!(text, model_id)
         validate_presence!(voice_id, 'voice_id')
-
-        settings = Objects::VoiceSettings::DEFAULTS.merge(voice_settings)
-
-        body = {
-          text: text,
-          model_id: model_id,
-          voice_settings: settings
-        }
+        body, dropped = build_body(text, model_id, voice_settings, optional_values(binding))
 
         path = "/text-to-speech/#{voice_id}/with-timestamps?output_format=#{output_format}"
-        response = post(path, body)
+        result = post_with_meta(path, body)
+        response = result[:body]
+        request_id = result[:headers]['request-id']
+        character_cost = integer_header(result[:headers], 'character-cost')
 
         # Decode base64 audio
         audio_data = Base64.decode64(response['audio_base64']) if response['audio_base64']
@@ -139,25 +199,72 @@ module ElevenRb
                     format: output_format,
                     voice_id: voice_id,
                     text: text,
-                    model_id: model_id
+                    model_id: model_id,
+                    request_id: request_id,
+                    character_cost: character_cost,
+                    dropped_settings: dropped
                   )
                 end
 
         {
           audio: audio,
-          alignment: response['alignment']
+          alignment: response['alignment'],
+          normalized_alignment: response['normalized_alignment'],
+          request_id: request_id,
+          character_cost: character_cost
         }
       end
 
       private
 
-      def validate_text!(text)
+      # Shared request body for generate / stream / generate_with_timestamps
+      #
+      # @return [Array(Hash, Array<Symbol>)] the body and the dropped voice-setting keys
+      def build_body(text, model_id, voice_settings, options)
+        settings, dropped = resolve_voice_settings(model_id, voice_settings)
+
+        body = { text: text, model_id: model_id, voice_settings: settings }
+        OPTIONAL_BODY_KEYS.each do |key|
+          body[key] = options[key] unless options[key].nil?
+        end
+
+        [body, dropped]
+      end
+
+      # The optional keyword values of the calling method, keyed by OPTIONAL_BODY_KEYS
+      def optional_values(caller_binding)
+        OPTIONAL_BODY_KEYS.to_h { |key| [key, caller_binding.local_variable_get(key)] }
+      end
+
+      def resolve_voice_settings(model_id, voice_settings)
+        settings, dropped = Objects::VoiceSettings.for_model(model_id, voice_settings)
+        return [settings, dropped] if dropped.empty?
+
+        message = "voice settings #{dropped.join(', ')} are not supported by #{model_id} " \
+                  "(supported: #{ModelCapabilities.supported_voice_settings(model_id).join(', ')})"
+        raise Errors::ValidationError, message if http_client.config.strict_voice_settings
+
+        http_client.config.logger&.warn("[ElevenRb] #{message}; dropped from the request")
+        [settings, dropped]
+      end
+
+      def integer_header(headers, name)
+        value = headers[name]
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        Integer(value.to_s.strip, 10)
+      rescue ArgumentError
+        nil
+      end
+
+      def validate_text!(text, model_id = DEFAULT_MODEL)
         validate_presence!(text, 'text')
 
-        return unless text.length > MAX_TEXT_LENGTH
+        max_length = ModelCapabilities.max_text_length(model_id)
+        return unless text.length > max_length
 
         raise Errors::ValidationError,
-              "text exceeds maximum length of #{MAX_TEXT_LENGTH} characters (got #{text.length})"
+              "text exceeds maximum length of #{max_length} characters for #{model_id} (got #{text.length})"
       end
     end
   end

data/lib/eleven_rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ElevenRb
-  VERSION = '0.4.0'
+  VERSION = '1.1.0'
 end

data/lib/eleven_rb.rb

@@ -60,6 +60,7 @@ module ElevenRb
         retry_delay: config.retry_delay,
         retry_statuses: config.retry_statuses,
         logger: config.logger,
+        strict_voice_settings: config.strict_voice_settings,
         on_request: config.on_request,
         on_response: config.on_response,
         on_error: config.on_error,
@@ -79,6 +80,7 @@ require_relative 'eleven_rb/errors'
 require_relative 'eleven_rb/callbacks'
 require_relative 'eleven_rb/instrumentation'
 require_relative 'eleven_rb/configuration'
+require_relative 'eleven_rb/model_capabilities'
 
 # HTTP layer
 require_relative 'eleven_rb/http/client'
@@ -109,6 +111,7 @@ require_relative 'eleven_rb/resources/user'
 require_relative 'eleven_rb/resources/sound_effects'
 require_relative 'eleven_rb/resources/music'
 require_relative 'eleven_rb/resources/speech_to_speech'
+require_relative 'eleven_rb/resources/text_to_dialogue'
 
 # High-level components
 require_relative 'eleven_rb/voice_slot_manager'