ruby_llm-agents 3.5.4 → 3.6.0

data/lib/ruby_llm/agents/agent_tool.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Wraps an agent class as a RubyLLM::Tool so it can be used
+    # in another agent's `tools` list. The LLM sees the sub-agent
+    # as a callable tool and can invoke it with the agent's declared params.
+    module AgentTool
+      MAX_AGENT_TOOL_DEPTH = 5
+
+      # Wraps an agent class as a RubyLLM::Tool subclass.
+      #
+      # @param agent_class [Class] A BaseAgent subclass
+      # @return [Class] An anonymous RubyLLM::Tool subclass
+      def self.for(agent_class)
+        tool_name = derive_tool_name(agent_class)
+        tool_desc = agent_class.respond_to?(:description) ? agent_class.description : nil
+        agent_params = agent_class.respond_to?(:params) ? agent_class.params : {}
+        captured_agent_class = agent_class
+
+        Class.new(RubyLLM::Tool) do
+          description tool_desc if tool_desc
+
+          # Map agent params to tool params
+          agent_params.each do |name, config|
+            next if name.to_s.start_with?("_")
+
+            param name,
+              desc: config[:desc] || "#{name} parameter",
+              required: config[:required] == true,
+              type: AgentTool.map_type(config[:type])
+          end
+
+          # Store references on the class
+          define_singleton_method(:agent_class) { captured_agent_class }
+          define_singleton_method(:tool_name) { tool_name }
+
+          # Instance #name returns the derived tool name
+          define_method(:name) { tool_name }
+
+          define_method(:execute) do |**kwargs|
+            depth = (Thread.current[:ruby_llm_agents_tool_depth] || 0) + 1
+            if depth > MAX_AGENT_TOOL_DEPTH
+              return "Error calling #{captured_agent_class.name}: Agent tool depth exceeded (max #{MAX_AGENT_TOOL_DEPTH})"
+            end
+
+            Thread.current[:ruby_llm_agents_tool_depth] = depth
+
+            # Inject hierarchy context from thread-local (set by calling agent)
+            caller_ctx = Thread.current[:ruby_llm_agents_caller_context]
+
+            call_kwargs = kwargs.dup
+            if caller_ctx
+              call_kwargs[:_parent_execution_id] = caller_ctx.execution_id
+              call_kwargs[:_root_execution_id] = caller_ctx.root_execution_id || caller_ctx.execution_id
+              call_kwargs[:tenant] = caller_ctx.tenant_object if caller_ctx.tenant_id && !call_kwargs.key?(:tenant)
+            end
+
+            result = captured_agent_class.call(**call_kwargs)
+            content = result.respond_to?(:content) ? result.content : result
+            case content
+            when String then content
+            when Hash then content.to_json
+            when nil then "(no response)"
+            else content.to_s
+            end
+          rescue => e
+            "Error calling #{captured_agent_class.name}: #{e.message}"
+          ensure
+            Thread.current[:ruby_llm_agents_tool_depth] = depth - 1
+          end
+        end
+      end
+
+      # Converts agent class name to tool name.
+      #
+      # @example
+      #   ResearchAgent    -> "research"
+      #   CodeReviewAgent  -> "code_review"
+      #
+      # @param agent_class [Class] The agent class
+      # @return [String] Snake-cased tool name
+      def self.derive_tool_name(agent_class)
+        raw = agent_class.name.to_s.split("::").last
+        raw.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+          .sub(/_agent$/, "")
+      end
+
+      # Maps Ruby types to JSON Schema types for tool parameters.
+      #
+      # @param type [Class, Symbol, nil] Ruby type
+      # @return [Symbol] JSON Schema type
+      def self.map_type(type)
+        case type
+        when :integer then :integer
+        when :number, :float then :number
+        when :boolean then :boolean
+        when :array then :array
+        when :object then :object
+        else
+          # Handle class objects (Integer, Float, Array, Hash, etc.)
+          if type.is_a?(Class)
+            if type <= Integer
+              :integer
+            elsif type <= Float
+              :number
+            elsif type <= Array
+              :array
+            elsif type <= Hash
+              :object
+            elsif type == TrueClass || type == FalseClass
+              :boolean
+            else
+              :string
+            end
+          else
+            :string
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -352,7 +352,8 @@ module RubyLLM
           started_at: context.started_at || execution_started_at,
           completed_at: execution_completed_at,
           duration_ms: duration_ms,
-          tenant_id: context.tenant_id
+          tenant_id: context.tenant_id,
+          execution_id: context.execution_id
         )
       end
 
@@ -527,7 +528,7 @@ module RubyLLM
       end
 
       # Builds the final result object
-      def build_result(raw_result, original_text, started_at:, completed_at:, duration_ms:, tenant_id:)
+      def build_result(raw_result, original_text, started_at:, completed_at:, duration_ms:, tenant_id:, execution_id: nil)
         SpeechResult.new(
           audio: raw_result[:audio],
           duration: raw_result[:duration],
@@ -544,7 +545,8 @@ module RubyLLM
           completed_at: completed_at,
           total_cost: calculate_cost(raw_result),
           status: :success,
-          tenant_id: tenant_id
+          tenant_id: tenant_id,
+          execution_id: execution_id
         )
       end
 

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

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "json"
+require_relative "../pricing/data_store"
+require_relative "../pricing/ruby_llm_adapter"
+require_relative "../pricing/litellm_adapter"
 
 module RubyLLM
   module Agents
     module Audio
       # Dynamic pricing resolution for text-to-speech models.
       #
-      # Uses a four-tier pricing cascade:
-      # 1. LiteLLM JSON (primary) - future-proof, auto-updating
-      # 2. Configurable pricing table - user overrides via config.tts_model_pricing
-      # 3. ElevenLabs API - dynamic multiplier × base rate from /v1/models
-      # 4. Hardcoded fallbacks - per-model defaults
+      # Uses a three-tier pricing cascade (no hardcoded prices):
+      # 1. Configurable pricing table - user overrides via config.tts_model_pricing
+      # 2. LiteLLM (via shared DataStore) - comprehensive, community-maintained
+      # 3. ElevenLabs API - dynamic multiplier × user-configured base rate
+      #
+      # When no pricing is found, returns 0 to signal unknown cost.
       #
       # All prices are per 1,000 characters.
       #
@@ -31,9 +33,6 @@ module RubyLLM
       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
@@ -49,150 +48,91 @@ module RubyLLM
         #
         # @param provider [Symbol] Provider identifier
         # @param model_id [String] Model identifier
-        # @return [Float] Cost per 1K characters in USD
+        # @return [Float] Cost per 1K characters in USD (0 if unknown)
         def cost_per_1k_characters(provider, model_id)
-          # Tier 1: LiteLLM
-          if (litellm_price = from_litellm(model_id))
-            return litellm_price
-          end
-
-          # Tier 2: User config overrides
+          # Tier 1: User config overrides (highest priority)
           if (config_price = from_config(model_id))
             return config_price
           end
 
-          # Tier 3: ElevenLabs API multiplier × base rate
+          # Tier 2: LiteLLM (via shared adapter/DataStore)
+          if (litellm_price = from_litellm(model_id))
+            return litellm_price
+          end
+
+          # Tier 3: ElevenLabs API multiplier × user-configured base rate
           if provider == :elevenlabs && (api_price = from_elevenlabs_api(model_id))
             return api_price
           end
 
-          # Tier 4: Hardcoded fallbacks
-          fallback_price(provider, model_id)
+          # No pricing found — return user-configured default or 0
+          config.default_tts_cost || 0
         end
 
-        # Force refresh of cached LiteLLM data
+        # Force refresh of cached pricing data
         def refresh!
-          @litellm_data = nil
-          @litellm_fetched_at = nil
-          litellm_data
+          Pricing::DataStore.refresh!
         end
 
-        # Expose all known pricing for debugging/dashboard
+        # Expose all known pricing for debugging/console inspection
         def all_pricing
           {
             litellm: litellm_tts_models,
             configured: config.tts_model_pricing || {},
-            elevenlabs_api: elevenlabs_api_pricing,
-            fallbacks: fallback_pricing_table
+            elevenlabs_api: elevenlabs_api_pricing
           }
         end
 
         private
 
         # ============================================================
-        # Tier 1: LiteLLM
+        # Tier 1: User configuration
         # ============================================================
 
-        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 from_config(model_id)
+          table = config.tts_model_pricing
+          return nil unless table.is_a?(Hash) && !table.empty?
 
-        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
+          price = table[model_id] || table[normalized] ||
+            table[model_id.to_sym] || table[normalized.to_sym]
 
-          data.find do |key, _|
-            key.to_s.downcase.include?(normalized.downcase)
-          end&.last
+          price if price.is_a?(Numeric)
         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
+        # ============================================================
+        # Tier 2: LiteLLM (via shared DataStore + adapter)
+        # ============================================================
 
-        def litellm_data
-          return @litellm_data if @litellm_data && !cache_expired?
+        def from_litellm(model_id)
+          data = Pricing::LiteLLMAdapter.find_model(model_id)
+          return nil unless data
 
-          @litellm_data = fetch_litellm_data
-          @litellm_fetched_at = Time.now
-          @litellm_data
+          extract_tts_price(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
+        def extract_tts_price(data)
+          if data[:input_cost_per_character]
+            return (data[:input_cost_per_character] * 1000).round(6)
           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
-            {}
+          if data[:output_cost_per_character]
+            return (data[:output_cost_per_character] * 1000).round(6)
           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
+          if data[:output_cost_per_audio_token]
+            return (data[:output_cost_per_audio_token] * 250).round(6)
+          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
+          nil
         end
 
         def litellm_tts_models
-          litellm_data.select do |key, value|
+          data = Pricing::DataStore.litellm_data
+          return {} unless data.is_a?(Hash)
+
+          data.select do |key, value|
             value.is_a?(Hash) && (
               value["input_cost_per_character"] ||
               key.to_s.match?(/tts|speech|eleven/i)
@@ -200,35 +140,6 @@ module RubyLLM
           end
         end
 
-        def elevenlabs_api_pricing
-          return {} unless defined?(ElevenLabs::ModelRegistry)
-
-          base = config.elevenlabs_base_cost_per_1k || 0.30
-          ElevenLabs::ModelRegistry.models.each_with_object({}) do |model, hash|
-            multiplier = model.dig("model_rates", "character_cost_multiplier") || 1.0
-            hash[model["model_id"]] = (base * multiplier).round(6)
-          end
-        rescue => e
-          warn "[RubyLLM::Agents] Failed to get ElevenLabs API pricing: #{e.message}"
-          {}
-        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: ElevenLabs API (dynamic multiplier × base rate)
         # ============================================================
@@ -236,67 +147,32 @@ module RubyLLM
         def from_elevenlabs_api(model_id)
           return nil unless defined?(ElevenLabs::ModelRegistry)
 
+          base = config.elevenlabs_base_cost_per_1k
+          return nil unless base
+
           model = ElevenLabs::ModelRegistry.find(model_id)
           return nil unless model
 
           multiplier = model.dig("model_rates", "character_cost_multiplier") || 1.0
-          base = config.elevenlabs_base_cost_per_1k || 0.30
           (base * multiplier).round(6)
         rescue => e
           warn "[RubyLLM::Agents] Failed to get ElevenLabs API pricing: #{e.message}"
           nil
         end
 
-        # ============================================================
-        # Tier 4: 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 elevenlabs_api_pricing
+          return {} unless defined?(ElevenLabs::ModelRegistry)
 
-        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
+          base = config.elevenlabs_base_cost_per_1k
+          return {} unless base
 
-        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
+          ElevenLabs::ModelRegistry.models.each_with_object({}) do |model, hash|
+            multiplier = model.dig("model_rates", "character_cost_multiplier") || 1.0
+            hash[model["model_id"]] = (base * multiplier).round(6)
           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
-          }
+        rescue => e
+          warn "[RubyLLM::Agents] Failed to get ElevenLabs API pricing: #{e.message}"
+          {}
         end
 
         def normalize_model_id(model_id)

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

@@ -341,7 +341,8 @@ module RubyLLM
           started_at: context.started_at || execution_started_at,
           completed_at: execution_completed_at,
           duration_ms: duration_ms,
-          tenant_id: context.tenant_id
+          tenant_id: context.tenant_id,
+          execution_id: context.execution_id
         )
       end
 
@@ -597,7 +598,7 @@ module RubyLLM
       end
 
       # Builds the final result object
-      def build_result(raw_result, started_at:, completed_at:, duration_ms:, tenant_id:)
+      def build_result(raw_result, started_at:, completed_at:, duration_ms:, tenant_id:, execution_id: nil)
         # Apply post-processing
         text = raw_result[:text] ? postprocess_text(raw_result[:text]) : nil
 
@@ -615,7 +616,8 @@ module RubyLLM
           total_cost: calculate_cost(raw_result),
           audio_minutes: raw_result[:duration] ? raw_result[:duration] / 60.0 : nil,
           status: :success,
-          tenant_id: tenant_id
+          tenant_id: tenant_id,
+          execution_id: execution_id
         )
       end
 

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

@@ -39,8 +39,6 @@ module RubyLLM
       module TranscriptionPricing
         extend self
 
-        LITELLM_PRICING_URL = Pricing::DataStore::LITELLM_URL
-
         SOURCES = [:config, :ruby_llm, :litellm, :portkey, :openrouter, :helicone, :llmpricing].freeze
 
         # Calculate total cost for a transcription operation
@@ -81,16 +79,16 @@ module RubyLLM
           Pricing::DataStore.refresh!
         end
 
-        # Expose all known pricing for debugging/dashboard
+        # Expose all known pricing for debugging/console inspection
         #
         # @return [Hash] Pricing from all tiers
         def all_pricing
           {
-            ruby_llm: {},  # local gem, per-model lookup
+            ruby_llm: {},
             litellm: litellm_transcription_models,
-            portkey: {},  # per-model, populated on demand
-            openrouter: {},  # no dedicated transcription models
-            helicone: {},  # no transcription models
+            portkey: {},
+            openrouter: {},
+            helicone: {},
             configured: config.transcription_model_pricing || {}
           }
         end