ruby_llm-agents 3.1.0 → 3.3.0

data/lib/ruby_llm/agents/audio/speech_pricing.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module RubyLLM
+  module Agents
+    module Audio
+      # Dynamic pricing resolution for text-to-speech models.
+      #
+      # Uses the same three-tier strategy as ImageGenerator::Pricing:
+      # 1. LiteLLM JSON (primary) - future-proof, auto-updating
+      # 2. Configurable pricing table - user overrides via config.tts_model_pricing
+      # 3. Hardcoded fallbacks - per-model defaults
+      #
+      # All prices are per 1,000 characters.
+      #
+      # @example Get cost for a speech operation
+      #   SpeechPricing.calculate_cost(provider: :openai, model_id: "tts-1", characters: 5000)
+      #   # => 0.075
+      #
+      # @example User-configured pricing
+      #   RubyLLM::Agents.configure do |c|
+      #     c.tts_model_pricing = {
+      #       "eleven_v3" => 0.24,
+      #       "tts-1" => 0.015
+      #     }
+      #   end
+      #
+      module SpeechPricing
+        extend self
+
+        LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
+        DEFAULT_CACHE_TTL = 24 * 60 * 60 # 24 hours
+
+        # Calculate total cost for a speech operation
+        #
+        # @param provider [Symbol] :openai or :elevenlabs
+        # @param model_id [String] The model identifier
+        # @param characters [Integer] Number of characters synthesized
+        # @return [Float] Total cost in USD
+        def calculate_cost(provider:, model_id:, characters:)
+          price_per_1k = cost_per_1k_characters(provider, model_id)
+          ((characters / 1000.0) * price_per_1k).round(6)
+        end
+
+        # Get cost per 1,000 characters for a model
+        #
+        # @param provider [Symbol] Provider identifier
+        # @param model_id [String] Model identifier
+        # @return [Float] Cost per 1K characters in USD
+        def cost_per_1k_characters(provider, model_id)
+          if (litellm_price = from_litellm(model_id))
+            return litellm_price
+          end
+
+          if (config_price = from_config(model_id))
+            return config_price
+          end
+
+          fallback_price(provider, model_id)
+        end
+
+        # Force refresh of cached LiteLLM data
+        def refresh!
+          @litellm_data = nil
+          @litellm_fetched_at = nil
+          litellm_data
+        end
+
+        # Expose all known pricing for debugging/dashboard
+        def all_pricing
+          {
+            litellm: litellm_tts_models,
+            configured: config.tts_model_pricing || {},
+            fallbacks: fallback_pricing_table
+          }
+        end
+
+        private
+
+        # ============================================================
+        # Tier 1: LiteLLM
+        # ============================================================
+
+        def from_litellm(model_id)
+          data = litellm_data
+          return nil unless data
+
+          model_data = find_litellm_model(data, model_id)
+          return nil unless model_data
+
+          extract_litellm_tts_price(model_data)
+        end
+
+        def find_litellm_model(data, model_id)
+          normalized = normalize_model_id(model_id)
+
+          candidates = [
+            model_id,
+            normalized,
+            "tts/#{model_id}",
+            "openai/#{model_id}",
+            "elevenlabs/#{model_id}"
+          ]
+
+          candidates.each do |key|
+            return data[key] if data[key]
+          end
+
+          data.find do |key, _|
+            key.to_s.downcase.include?(normalized.downcase)
+          end&.last
+        end
+
+        def extract_litellm_tts_price(model_data)
+          if model_data["input_cost_per_character"]
+            return model_data["input_cost_per_character"] * 1000
+          end
+
+          if model_data["output_cost_per_character"]
+            return model_data["output_cost_per_character"] * 1000
+          end
+
+          if model_data["output_cost_per_audio_token"]
+            return model_data["output_cost_per_audio_token"] * 250
+          end
+
+          nil
+        end
+
+        def litellm_data
+          return @litellm_data if @litellm_data && !cache_expired?
+
+          @litellm_data = fetch_litellm_data
+          @litellm_fetched_at = Time.now
+          @litellm_data
+        end
+
+        def fetch_litellm_data
+          if defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache
+            Rails.cache.fetch("litellm_tts_pricing_data", expires_in: cache_ttl) do
+              fetch_from_url
+            end
+          else
+            fetch_from_url
+          end
+        rescue => e
+          warn "[RubyLLM::Agents] Failed to fetch LiteLLM TTS pricing: #{e.message}"
+          {}
+        end
+
+        def fetch_from_url
+          uri = URI(config.litellm_pricing_url || LITELLM_PRICING_URL)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.open_timeout = 5
+          http.read_timeout = 10
+
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+
+          if response.is_a?(Net::HTTPSuccess)
+            JSON.parse(response.body)
+          else
+            {}
+          end
+        rescue => e
+          warn "[RubyLLM::Agents] HTTP error fetching LiteLLM pricing: #{e.message}"
+          {}
+        end
+
+        def cache_expired?
+          return true unless @litellm_fetched_at
+          Time.now - @litellm_fetched_at > cache_ttl
+        end
+
+        def cache_ttl
+          ttl = config.litellm_pricing_cache_ttl
+          return DEFAULT_CACHE_TTL unless ttl
+          ttl.respond_to?(:to_i) ? ttl.to_i : ttl
+        end
+
+        def litellm_tts_models
+          litellm_data.select do |key, value|
+            value.is_a?(Hash) && (
+              value["input_cost_per_character"] ||
+              key.to_s.match?(/tts|speech|eleven/i)
+            )
+          end
+        end
+
+        # ============================================================
+        # Tier 2: User configuration
+        # ============================================================
+
+        def from_config(model_id)
+          table = config.tts_model_pricing
+          return nil unless table.is_a?(Hash) && !table.empty?
+
+          normalized = normalize_model_id(model_id)
+
+          price = table[model_id] || table[normalized] ||
+            table[model_id.to_sym] || table[normalized.to_sym]
+
+          price if price.is_a?(Numeric)
+        end
+
+        # ============================================================
+        # Tier 3: Hardcoded fallbacks
+        # ============================================================
+
+        def fallback_price(provider, model_id)
+          normalized = normalize_model_id(model_id)
+
+          case provider
+          when :openai
+            openai_fallback_price(normalized)
+          when :elevenlabs
+            elevenlabs_fallback_price(normalized)
+          else
+            config.default_tts_cost || 0.015
+          end
+        end
+
+        def openai_fallback_price(model_id)
+          case model_id
+          when /tts-1-hd/ then 0.030
+          when /tts-1/ then 0.015
+          else 0.015
+          end
+        end
+
+        def elevenlabs_fallback_price(model_id)
+          case model_id
+          when /eleven_flash_v2/ then 0.15
+          when /eleven_turbo_v2/ then 0.15
+          when /eleven_v3/ then 0.30
+          when /eleven_multilingual_v2/ then 0.30
+          when /eleven_multilingual_v1/ then 0.30
+          when /eleven_monolingual_v1/ then 0.30
+          else 0.30
+          end
+        end
+
+        def fallback_pricing_table
+          {
+            "tts-1" => 0.015,
+            "tts-1-hd" => 0.030,
+            "eleven_monolingual_v1" => 0.30,
+            "eleven_multilingual_v1" => 0.30,
+            "eleven_multilingual_v2" => 0.30,
+            "eleven_turbo_v2" => 0.15,
+            "eleven_flash_v2" => 0.15,
+            "eleven_turbo_v2_5" => 0.15,
+            "eleven_flash_v2_5" => 0.15,
+            "eleven_v3" => 0.30
+          }
+        end
+
+        def normalize_model_id(model_id)
+          model_id.to_s.downcase
+            .gsub(/[^a-z0-9._-]/, "-").squeeze("-")
+            .gsub(/^-|-$/, "")
+        end
+
+        def config
+          RubyLLM::Agents.configuration
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/agents/audio/transcriber.rb

@@ -166,7 +166,7 @@ module RubyLLM
 
         def default_transcription_model
           RubyLLM::Agents.configuration.default_transcription_model
-        rescue StandardError
+        rescue
           "whisper-1"
         end
       end
@@ -318,6 +318,16 @@ module RubyLLM
         context.output_tokens = 0
         context.total_cost = calculate_cost(raw_result)
 
+        # Store transcription-specific metadata for execution tracking
+        context[:language] = resolved_language if resolved_language
+        context[:detected_language] = raw_result[:language] if raw_result[:language]
+        context[:audio_duration_seconds] = raw_result[:duration] if raw_result[:duration]
+        context[:audio_minutes] = (raw_result[:duration] / 60.0).round(4) if raw_result[:duration]
+        context[:output_format] = self.class.output_format.to_s
+        context[:timestamp_granularity] = self.class.include_timestamps.to_s
+        context[:segment_count] = raw_result[:segments]&.size if raw_result[:segments]
+        context[:word_count] = raw_result[:text]&.split(/\s+/)&.size if raw_result[:text]
+
         # Build final result
         context.output = build_result(
           raw_result,
@@ -334,22 +344,22 @@ module RubyLLM
       def agent_cache_key
         # Generate content hash based on input type
         content_hash = case @audio
-                       when String
-                         if @audio.start_with?("http://", "https://")
-                           Digest::SHA256.hexdigest(@audio)
-                         elsif File.exist?(@audio)
-                           Digest::SHA256.file(@audio).hexdigest
-                         else
-                           Digest::SHA256.hexdigest(@audio)
-                         end
-                       when File, IO
-                         @audio.rewind if @audio.respond_to?(:rewind)
-                         Digest::SHA256.hexdigest(@audio.read).tap do
-                           @audio.rewind if @audio.respond_to?(:rewind)
-                         end
-                       else
-                         Digest::SHA256.hexdigest(@audio.to_s)
-                       end
+        when String
+          if @audio.start_with?("http://", "https://")
+            Digest::SHA256.hexdigest(@audio)
+          elsif File.exist?(@audio)
+            Digest::SHA256.file(@audio).hexdigest
+          else
+            Digest::SHA256.hexdigest(@audio)
+          end
+        when File, IO
+          @audio.rewind if @audio.respond_to?(:rewind)
+          Digest::SHA256.hexdigest(@audio.read).tap do
+            @audio.rewind if @audio.respond_to?(:rewind)
+          end
+        else
+          Digest::SHA256.hexdigest(@audio.to_s)
+        end
 
         components = [
           "ruby_llm_agents",
@@ -389,15 +399,15 @@ module RubyLLM
         case audio
         when String
           if audio.start_with?("http://", "https://")
-            { source: audio, type: :url }
+            {source: audio, type: :url}
           elsif looks_like_file_path?(audio)
-            { source: audio, type: :file_path }
+            {source: audio, type: :file_path}
           else
             # Assume it's binary data
-            { source: audio, type: :binary, format: format }
+            {source: audio, type: :binary, format: format}
           end
         when File, IO
-          { source: audio, type: :file_object }
+          {source: audio, type: :file_object}
         else
           raise ArgumentError, "audio must be a file path, URL, File object, or binary data"
         end
@@ -451,7 +461,7 @@ module RubyLLM
 
           begin
             return execute_transcription(audio_input, model)
-          rescue StandardError => e
+          rescue => e
             last_error = e
             retries += 1
 
@@ -498,7 +508,7 @@ module RubyLLM
       # @param model [String] Model to use
       # @return [Hash] Options for transcription
       def build_transcribe_options(model)
-        options = { model: model }
+        options = {model: model}
 
         # Add language if specified
         lang = resolved_language
@@ -618,15 +628,15 @@ module RubyLLM
         # Estimate based on model and duration
         model = raw_result[:model].to_s
         price_per_minute = case model
-                           when /whisper-1/
-                             0.006
-                           when /gpt-4o-transcribe/
-                             0.01
-                           when /gpt-4o-mini-transcribe/
-                             0.005
-                           else
-                             0.006 # Default to whisper pricing
-                           end
+        when /whisper-1/
+          0.006
+        when /gpt-4o-transcribe/
+          0.01
+        when /gpt-4o-mini-transcribe/
+          0.005
+        else
+          0.006 # Default to whisper pricing
+        end
 
         duration_minutes * price_per_minute
       end
@@ -657,7 +667,7 @@ module RubyLLM
       # Calculates exponential backoff delay
       def calculate_backoff(attempt)
         config = self.class.reliability_config
-        base = config&.backoff == :constant ? 1.0 : 0.4
+        base = (config&.backoff == :constant) ? 1.0 : 0.4
         max_delay = 10.0
 
         delay = base * (2**(attempt - 1))

data/lib/ruby_llm/agents/base_agent.rb

@@ -133,7 +133,7 @@ module RubyLLM
         # @return [void]
         def param(name, required: false, default: nil, type: nil)
           @params ||= {}
-          @params[name] = { required: required, default: default, type: type }
+          @params[name] = {required: required, default: default, type: type}
           define_method(name) do
             @options[name] || @options[name.to_s] || self.class.params.dig(name, :default)
           end
@@ -217,7 +217,7 @@ module RubyLLM
 
           # Fall back to global configuration default
           RubyLLM::Agents.configuration.default_thinking
-        rescue StandardError
+        rescue
           nil
         end
 
@@ -227,13 +227,13 @@ module RubyLLM
 
         def default_streaming
           RubyLLM::Agents.configuration.default_streaming
-        rescue StandardError
+        rescue
           false
         end
 
         def default_temperature
           RubyLLM::Agents.configuration.default_temperature
-        rescue StandardError
+        rescue
           0.7
         end
       end
@@ -455,7 +455,7 @@ module RubyLLM
         if tenant_value.is_a?(Hash)
           tenant_value
         elsif tenant_value.respond_to?(:llm_tenant_id)
-          { id: tenant_value.llm_tenant_id, object: tenant_value }
+          {id: tenant_value.llm_tenant_id, object: tenant_value}
         else
           raise ArgumentError, "tenant must be a Hash or respond to :llm_tenant_id"
         end
@@ -465,7 +465,7 @@ module RubyLLM
       #
       # @return [Array<Class>] Tool classes to use
       def resolved_tools
-        if self.class.instance_methods(false).include?(:tools)
+        if self.class.method_defined?(:tools, false)
           tools
         else
           self.class.tools
@@ -493,7 +493,7 @@ module RubyLLM
         prefill = assistant_prompt
         return nil if prefill.nil? || (prefill.is_a?(String) && prefill.empty?)
 
-        { role: :assistant, content: prefill }
+        {role: :assistant, content: prefill}
       end
 
       # Returns whether streaming is enabled
@@ -544,7 +544,7 @@ module RubyLLM
 
           if config[:type] && has_value && !value.nil? && !value.is_a?(config[:type])
             raise ArgumentError,
-                  "#{self.class} expected #{config[:type]} for :#{name}, got #{value.class}"
+              "#{self.class} expected #{config[:type]} for :#{name}, got #{value.class}"
           end
         end
       end
@@ -594,8 +594,8 @@ module RubyLLM
       def build_client(context = nil)
         effective_model = context&.model || model
         client = RubyLLM.chat
-                        .with_model(effective_model)
-                        .with_temperature(temperature)
+          .with_model(effective_model)
+          .with_temperature(temperature)
 
         client = client.with_instructions(system_prompt) if system_prompt
         client = client.with_schema(schema) if schema
@@ -735,7 +735,7 @@ module RubyLLM
         return nil unless defined?(RubyLLM::Models)
 
         RubyLLM::Models.find(model_id)
-      rescue StandardError
+      rescue
         nil
       end
 
@@ -789,7 +789,7 @@ module RubyLLM
       # @return [Hash] Hash with thinking data or empty hash
       def safe_extract_thinking_data(response)
         result_thinking_data(response)
-      rescue StandardError
+      rescue
         {}
       end
 
@@ -894,7 +894,7 @@ module RubyLLM
           content = result.to_s
         end
 
-        { content: content, status: status, error_message: error_message }
+        {content: content, status: status, error_message: error_message}
       end
 
       # Truncates tool result if it exceeds the configured max length
@@ -917,7 +917,7 @@ module RubyLLM
       # @return [Integer] Max length
       def tool_result_max_length
         RubyLLM::Agents.configuration.tool_result_max_length || 10_000
-      rescue StandardError
+      rescue
         10_000
       end
 

data/lib/ruby_llm/agents/core/base/callbacks.rb

@@ -49,7 +49,7 @@ module RubyLLM
       #   before_call { |context| context.params[:sanitized] = true }
       #
       def before_call(method_name = nil, &block)
-        @callbacks ||= { before: [], after: [] }
+        @callbacks ||= {before: [], after: []}
         @callbacks[:before] << (block || method_name)
       end
 
@@ -71,7 +71,7 @@ module RubyLLM
       #   after_call { |context, response| notify_completion(response) }
       #
       def after_call(method_name = nil, &block)
-        @callbacks ||= { before: [], after: [] }
+        @callbacks ||= {before: [], after: []}
         @callbacks[:after] << (block || method_name)
       end
 
@@ -112,7 +112,7 @@ module RubyLLM
       #
       # @return [Hash] Hash with :before and :after arrays
       def callbacks
-        @callbacks ||= { before: [], after: [] }
+        @callbacks ||= {before: [], after: []}
       end
     end