legion-llm 0.9.14 → 0.9.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc06bf006614fbb7a1052b368912ef58744e5b6509680c163c1b7ce0009e87d8
-  data.tar.gz: 91c96c5fee56c7fb4804ea3d58eb908cec12539a75eba11348e842be26509343
+  metadata.gz: ce44e3d928a848ab67e5cd50574c7454ff3490a455c1d040c7089641e1091e5e
+  data.tar.gz: ef3eaa05c9340b08f94af99c7b4f35334cef2a1d8dd09aeafb3535532840b4ce
 SHA512:
-  metadata.gz: fc3d9e91c66c0128bde4ffc434c19e6e75a21cb14a74cafe206235750ef402380a250c928358dfc7702f11f7259ffc46e5976a2abcf360c508bf8ceb7dca6033
-  data.tar.gz: 5d1a42619cc8e0d6e086b82245356b69790df2f7601313046e5d09e301ada70483f83ab53b4f6e592f5294c94f631904c7d46847131981542db173950e8e408c
+  metadata.gz: 1dc635c864ac647911bc6d55a34209f10273471b63683ab4eaa7dc69fdee7d3047c6b028b9d5180688b0b7ed4624c89fa90e5a7745f2462cb30371fe84607a11
+  data.tar.gz: ddd2e32d57a9a56d1fff22c4b7e423145d743183efd7044290482612b704b4c787db9790d28733df53e69a90ed57e4af1d7f6bef89f069ad3a25fafbe09b63ae

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Legion LLM Changelog
 
+## [0.9.17] - 2026-05-11
+
+### Fixed
+- `total_memory_mb` now fetched exactly once on first access and never re-fetched; hardware memory is static so repeated `sysctl` calls every 60s were wasteful. `refresh!` only clears the available memory cache; `reset!` still clears everything (for tests).
+- `trivial_query?` now correctly identifies short/trivial messages: a query is trivial if it matches a known trivial pattern (exact normalized match), or if no custom patterns are configured and the query is short (under `trivial_max_chars`) and a single word. Previously, an empty patterns list caused `.any?` to always return false, so nothing was ever trivial.
+- Added `trivial_patterns` helper with configurable defaults (`ping`, `pong`, `ding`, `test`, `foobar`) readable via `rag.trivial_patterns` setting; when custom patterns are explicitly configured, the short-query heuristic is disabled so only listed patterns are treated as trivial.
+
+## [0.9.16] - 2026-05-11
+
+### Fixed
+- Renamed `Metering#settings_value` to `extract_hash_value` to fix method shadowing with `Legion::Logging::Helper#settings_value`, which resolves a `wrong number of arguments (given 3, expected 2)` error raised from `instance_log_level` when metering is active.
+
+## [0.9.15] - 2026-05-08
+
+### Fixed
+- Normalize structured user message content before RAG query handling, preventing multipart API messages from crashing trivial-query detection or reaching Apollo as arrays.
+- Normalize empty string tool-call arguments to `{}` and make sticky tool history tolerate non-hash argument payloads without dropping state writes.
+- Pass non-executable API client tool calls through to callers as streaming `tool-call` events instead of dispatching them server-side as failed tool executions.
+- Add runtime logging for client tool receipt, native tool injection summaries, registry-injection skips, and returned tool-call SSE emission.
+
 ## [0.9.14] - 2026-05-08
 
 ### Fixed

data/lib/legion/llm/api/native/helpers.rb

@@ -347,6 +347,56 @@ module Legion
                 stream << "event: #{event_name}\ndata: #{Legion::JSON.dump(payload)}\n\n"
               end
 
+              define_method(:emit_response_tool_call_events) do |stream, pipeline_response|
+                tool_calls = extract_tool_calls(pipeline_response)
+                return if tool_calls.empty?
+
+                timeline_tool_call_ids = Array(pipeline_response.timeline).filter_map do |event|
+                  key = event[:key].to_s
+                  next unless key.start_with?('tool:execute:')
+
+                  data = event[:data].is_a?(Hash) ? event[:data] : {}
+                  data[:tool_call_id] || data['tool_call_id']
+                end
+
+                emitted = 0
+                skipped_timeline = 0
+                request_id = pipeline_response.respond_to?(:request_id) ? pipeline_response.request_id : 'unknown'
+                conversation_id = pipeline_response.respond_to?(:conversation_id) ? pipeline_response.conversation_id : 'none'
+
+                tool_calls.each do |tool_call|
+                  tool_call_id = tool_call[:id] || tool_call['id']
+                  if tool_call_id && timeline_tool_call_ids.include?(tool_call_id)
+                    skipped_timeline += 1
+                    next
+                  end
+
+                  tool_name = tool_call[:name] || tool_call['name']
+                  next if tool_name.to_s.empty?
+
+                  log.info(
+                    "[llm][api][tools] action=returned_tool_call_sse request_id=#{request_id || 'unknown'} " \
+                    "conversation_id=#{conversation_id || 'none'} tool_call_id=#{tool_call_id || 'none'} name=#{tool_name} " \
+                    "args_class=#{(tool_call[:arguments] || tool_call['arguments'] || {}).class}"
+                  )
+                  emit_sse_event(stream, 'tool-call', {
+                                   toolCallId: tool_call_id,
+                                   toolName:   tool_name,
+                                   args:       tool_call[:arguments] || tool_call['arguments'] || {},
+                                   timestamp:  Time.now.utc.iso8601
+                                 })
+                  emitted += 1
+                end
+
+                names = tool_calls.map { |tool_call| tool_call[:name] || tool_call['name'] }.compact
+                names = names.first(30).join(',') + (names.size > 30 ? ",+#{names.size - 30}more" : '')
+                log.info(
+                  "[llm][api][tools] action=returned_tool_calls_complete request_id=#{request_id || 'unknown'} " \
+                  "conversation_id=#{conversation_id || 'none'} total=#{tool_calls.size} emitted=#{emitted} " \
+                  "skipped_timeline=#{skipped_timeline} names=#{names.empty? ? 'none' : names}"
+                )
+              end
+
               define_method(:emit_timeline_tool_events) do |stream, pipeline_response, skip_tool_results: false|
                 timeline = Array(pipeline_response.timeline)
                 log.debug("[llm][api][helpers] emit_timeline_tool_events count=#{timeline.size} skip_tool_results=#{skip_tool_results}")

data/lib/legion/llm/api/native/inference.rb

@@ -72,7 +72,13 @@ module Legion
                 build_client_tool_class(ts[:name].to_s, ts[:description].to_s, ts[:parameters] || ts[:input_schema])
               end
 
-              log.debug("[llm][api][inference] action=tools_built client_tools=#{tool_declarations.size}")
+              client_tool_names = tool_declarations.map(&:name)
+              client_tool_summary = client_tool_names.empty? ? 'none' : client_tool_names.first(30).join(',')
+              client_tool_summary = "#{client_tool_summary},+#{client_tool_names.size - 30}more" if client_tool_names.size > 30
+              log.info(
+                "[llm][api][tools] action=client_tools_built request_id=#{request_id} " \
+                "conversation_id=#{conversation_id || 'none'} count=#{tool_declarations.size} names=#{client_tool_summary}"
+              )
 
               streaming = body[:stream] == true && request.preferred_type.to_s.include?('text/event-stream')
               effective_caller = build_server_caller(source: 'api', path: request.path, env: env,
@@ -155,6 +161,7 @@ module Legion
                     emit_sse_event(out, 'text-delta', { delta: text })
                   end
 
+                  emit_response_tool_call_events(out, pipeline_response)
                   emit_timeline_tool_events(out, pipeline_response, skip_tool_results: !executor.tool_event_handler.nil?)
 
                   enrichments = pipeline_response.enrichments

data/lib/legion/llm/call/dispatch.rb

@@ -332,11 +332,13 @@ module Legion
 
         def parse_arguments(arguments)
           return arguments unless arguments.is_a?(String)
+          return {} if arguments.strip.empty?
 
-          Legion::JSON.parse(arguments)
+          parsed = Legion::JSON.parse(arguments)
+          parsed.is_a?(Hash) ? parsed : {}
         rescue StandardError => e
           handle_exception(e, level: :debug, handled: true, operation: 'llm.dispatch.parse_arguments')
-          arguments
+          {}
         end
       end
     end

data/lib/legion/llm/context/curator.rb

@@ -247,11 +247,13 @@ module Legion
         def load_curated(conversation_id)
           return nil unless Inference::Conversation.conversation_exists?(conversation_id)
 
-          raw = Inference::Conversation.messages(conversation_id)
+          # Use raw_messages so CURATED_ROLE entries are visible even though they
+          # are filtered out of the public-facing Conversation#messages array.
+          raw = Inference::Conversation.raw_messages(conversation_id)
           curated_entries = raw.select { |m| m[:role] == CURATED_KEY }
           return nil if curated_entries.empty?
 
-          regular = raw.reject { |m| m[:role] == CURATED_KEY }
+          regular = raw.reject { |m| [CURATED_KEY, Inference::Conversation::METADATA_ROLE].include?(m[:role]) }
           summaries = normalized_curated_summaries(curated_entries)
           if summaries.empty?
             apply_curation_pipeline(regular)

data/lib/legion/llm/discovery/system.rb

@@ -31,9 +31,7 @@ module Legion
           end
 
           def refresh!
-            @total_fetched_at = nil
             @available_fetched_at = nil
-            @total_memory_mb = nil
             @available_memory_mb = nil
             @last_refreshed_at = Time.now
           end
@@ -57,7 +55,6 @@ module Legion
           private
 
           def ensure_total_fresh
-            refresh! if stale?
             return unless @total_fetched_at.nil?
 
             fetch_total

data/lib/legion/llm/inference/conversation.rb

@@ -11,6 +11,7 @@ module Legion
 
         MAX_CONVERSATIONS = 256
         METADATA_ROLE = :__metadata__
+        CURATED_ROLE  = :__curated__
 
         class << self
           def append(conversation_id, role:, content:, parent_id: nil, sidechain: false,
@@ -38,29 +39,41 @@ module Legion
 
           # Returns flat ordered message array — backward-compatible.
           # Uses chain reconstruction when parent links exist; falls back to seq order.
+          # Internal-only roles (__metadata__, __curated__) are filtered out.
           def messages(conversation_id)
             if in_memory?(conversation_id)
               touch(conversation_id)
-              raw = conversations[conversation_id][:messages].reject { |m| m[:role] == METADATA_ROLE }
+              raw = conversations[conversation_id][:messages].reject { |m| internal_role?(m[:role]) }
               chain_or_seq(raw)
             else
               load_from_db(conversation_id)
             end
           end
 
+          # Returns ALL messages including internal-role entries (__metadata__, __curated__).
+          # Use this when you need access to curation markers or metadata entries.
+          def raw_messages(conversation_id)
+            if in_memory?(conversation_id)
+              touch(conversation_id)
+              conversations[conversation_id][:messages].dup
+            else
+              load_all_from_db(conversation_id)
+            end
+          end
+
           # Build ordered chain from parent links.
           # Excludes sidechain messages by default.
           def build_chain(conversation_id, include_sidechains: false)
             raw = all_raw_messages(conversation_id)
             raw = raw.reject { |m| m[:sidechain] } unless include_sidechains
-            raw = raw.reject { |m| m[:role] == METADATA_ROLE }
+            raw = raw.reject { |m| internal_role?(m[:role]) }
             reconstruct_chain(raw)
           end
 
           # Return sidechain messages; optionally filter by agent_id.
           def sidechain_messages(conversation_id, agent_id: nil)
             raw = all_raw_messages(conversation_id)
-            result = raw.select { |m| m[:sidechain] && m[:role] != METADATA_ROLE }
+            result = raw.select { |m| m[:sidechain] && !internal_role?(m[:role]) }
             result = result.select { |m| m[:agent_id] == agent_id } unless agent_id.nil?
             result.sort_by { |m| m[:seq] }
           end
@@ -243,6 +256,12 @@ module Legion
 
           private
 
+          # Returns true for roles that are internal bookkeeping and should not
+          # appear in the public-facing message array returned by #messages.
+          def internal_role?(role)
+            [METADATA_ROLE, CURATED_ROLE].include?(role)
+          end
+
           def conversations
             @conversations ||= {}
           end
@@ -543,9 +562,22 @@ module Legion
                                .where(conversation_id: conversation_id)
                                .order(:seq)
                                .map { |row| symbolize_message(row) }
+                               .reject { |m| internal_role?(m[:role]) }
             chain_or_seq(rows)
           end
 
+          def load_all_from_db(conversation_id)
+            return [] unless db_available?
+
+            Legion::Data.connection[:conversation_messages]
+                        .where(conversation_id: conversation_id)
+                        .order(:seq)
+                        .map { |row| symbolize_message(row) }
+          rescue StandardError => e
+            handle_exception(e, level: :debug)
+            []
+          end
+
           def db_conversation_record?(conversation_id)
             Legion::Data.connection[:conversations].where(id: conversation_id).any?
           end

data/lib/legion/llm/inference/executor.rb

@@ -674,6 +674,7 @@ module Legion
               log.debug "[llm][executor] action=native_tool_loop.complete rounds=#{round} reason=no_tool_calls"
               return result
             end
+            return client_passthrough_tool_loop_result(result, tool_calls, round) if tool_calls.any? { |tool_call| client_passthrough_tool_call?(tool_call) }
 
             round += 1
             tool_names = tool_calls.map { |tc| tc[:name] }.join(',')
@@ -697,6 +698,7 @@ module Legion
             Array(@request.tools).each { |tool| add_native_tool_definition(definitions, tool) }
             add_registry_tool_definitions(definitions) if registry_tool_injection_requested?
             log.debug "[llm][executor] action=native_tool_definitions.built count=#{definitions.size}"
+            log_native_tool_definitions(definitions)
             definitions
           end
         end
@@ -728,9 +730,7 @@ module Legion
         end
 
         def add_registry_tool_definitions(definitions)
-          return unless Legion::Settings::Extensions.respond_to?(:tools) &&
-                        Legion::Settings::Extensions.respond_to?(:filter_tools)
-          return unless Array(Legion::Settings::Extensions.tools).any? || @triggered_tools.any?
+          return unless registry_tool_sources_available?
 
           add_settings_extensions_tool_definitions(definitions)
         rescue StandardError => e
@@ -841,7 +841,7 @@ module Legion
                        else
                          {}
                        end
-          normalized[:arguments] ||= {}
+          normalized[:arguments] = normalize_tool_arguments(normalized[:arguments])
           normalized[:id] ||= "call_#{SecureRandom.hex(12)}"
           normalized
         end

data/lib/legion/llm/inference/steps/rag_context.rb

@@ -127,18 +127,25 @@ module Legion
           def estimate_utilization
             return 0.0 if @request.tokens[:max].nil? || @request.tokens[:max].zero?
 
-            message_tokens = @request.messages.sum { |m| (m[:content]&.length || 0) / 4 }
+            message_tokens = @request.messages.sum { |m| content_text(message_content(m)).length / 4 }
             message_tokens.to_f / @request.tokens[:max]
           end
 
           def trivial_query?(query)
+            query = content_text(query)
             max_chars = rag_setting(:trivial_max_chars, 20)
-            patterns  = rag_setting(:trivial_patterns, [])
-
-            return false if query.length > max_chars
+            configured_patterns = rag_setting(:trivial_patterns)
 
             normalized = query.strip.downcase.gsub(/[^a-z0-9\s]/, '')
-            patterns.any? { |p| normalized == p }
+            patterns = configured_patterns || trivial_patterns
+            return true if patterns.any? { |p| normalized == p }
+            return true if configured_patterns.nil? && query.length <= max_chars && normalized.split.length <= 1
+
+            false
+          end
+
+          def trivial_patterns
+            rag_setting(:trivial_patterns, %w[ping pong ding test foobar])
           end
 
           def apollo_available?
@@ -247,7 +254,34 @@ module Legion
 
           def extract_query
             @request.messages.select { |m| Legion::LLM::Settings.config_value(m, :role).to_s == 'user' }
-                             .then { |messages| Legion::LLM::Settings.config_value(messages.last, :content) }
+                             .then { |messages| content_text(message_content(messages.last)) }
+          end
+
+          def message_content(message)
+            Legion::LLM::Settings.config_value(message, :content)
+          end
+
+          def content_text(content)
+            case content
+            when nil
+              ''
+            when String
+              content
+            when Array
+              content.filter_map { |entry| content_text(entry) }.join
+            when Hash
+              type = content[:type] || content['type']
+              return '' unless type.nil? || type.to_s == 'text'
+
+              text = if content.key?(:text) || content.key?('text')
+                       content[:text] || content['text']
+                     else
+                       content[:content] || content['content']
+                     end
+              content_text(text)
+            else
+              content.respond_to?(:text) ? content.text.to_s : content.to_s
+            end
           end
 
           def apply_gaia_context_limit(limit, strategy:)
@@ -286,7 +320,8 @@ module Legion
           def positive_integer(value)
             integer = Integer(value)
             integer.positive? ? integer : nil
-          rescue ArgumentError, TypeError
+          rescue ArgumentError, TypeError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.steps.rag_context.positive_integer')
             nil
           end
         end

data/lib/legion/llm/inference/steps/sticky_persist.rb

@@ -17,7 +17,7 @@ module Legion
             access_token private_key secret_key auth_token credential
           ].freeze
 
-          def step_sticky_persist # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/PerceivedComplexity
+          def step_sticky_persist # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
             return unless sticky_persist_ready?
 
             conv_id        = @request.conversation_id
@@ -100,7 +100,7 @@ module Legion
                   tool:   entry[:tool_name],
                   runner: runner_key,
                   turn:   @sticky_turn_snapshot,
-                  args:   sanitize_args(truncate_args(entry[:args] || {})),
+                  args:   sanitize_args(truncate_args(normalize_history_args(entry[:args]))),
                   result: entry[:result].to_s[0, max_result_length],
                   error:  entry[:error] || false
                 }
@@ -162,6 +162,25 @@ module Legion
             end
           end
 
+          def normalize_history_args(args)
+            case args
+            when nil
+              {}
+            when Hash
+              args
+            when String
+              return {} if args.strip.empty?
+
+              parsed = Legion::JSON.parse(args)
+              parsed.is_a?(Hash) ? parsed : {}
+            else
+              args.respond_to?(:to_h) ? args.to_h : {}
+            end
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.step_sticky_persist.normalize_args')
+            {}
+          end
+
           def sanitize_args(args)
             args.each_with_object({}) do |(k, v), h|
               h[k] = SENSITIVE_PARAM_NAMES.include?(k.to_s.downcase) ? '[REDACTED]' : v

data/lib/legion/llm/inference/steps/tool_calls.rb

@@ -32,6 +32,20 @@ module Legion
               source = find_tool_source(tool_name)
               next unless source
 
+              if client_passthrough_source?(source)
+                log.info(
+                  "[llm][tools] client_passthrough request_id=#{@request.id} " \
+                  "tool_call_id=#{tool_call_id || 'none'} name=#{tool_name}"
+                )
+                log_step_debug(
+                  :tool_calls,
+                  :client_passthrough,
+                  tool_call_id: tool_call_id || 'none',
+                  tool_name:    tool_name
+                )
+                next
+              end
+
               # Skip builtin tools; native providers handle provider-owned tools.
               if source[:type] == :builtin
                 log.info(
@@ -123,6 +137,102 @@ module Legion
             { type: :builtin }
           end
 
+          def client_passthrough_source?(source)
+            source[:type] == :client && source[:executable] != true
+          end
+
+          def client_passthrough_tool_call?(tool_call)
+            client_passthrough_source?(find_tool_source(tool_call[:name]))
+          end
+
+          def client_passthrough_tool_loop_result(result, tool_calls, round)
+            result[:tool_calls] = tool_calls
+            log.debug "[llm][executor] action=native_tool_loop.complete rounds=#{round} reason=client_passthrough"
+            result
+          end
+
+          def normalize_tool_arguments(arguments)
+            case arguments
+            when nil
+              {}
+            when Hash
+              arguments
+            when String
+              return {} if arguments.strip.empty?
+
+              parsed = Legion::JSON.parse(arguments)
+              parsed.is_a?(Hash) ? parsed : {}
+            else
+              arguments.respond_to?(:to_h) ? arguments.to_h : {}
+            end
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.normalize_tool_arguments')
+            {}
+          end
+
+          def registry_tool_sources_available?
+            unless Legion::Settings::Extensions.respond_to?(:tools) &&
+                   Legion::Settings::Extensions.respond_to?(:filter_tools)
+              log_tool_injection_skip(:settings_extensions_unavailable)
+              return false
+            end
+
+            settings_tool_count = Array(Legion::Settings::Extensions.tools).size
+            if settings_tool_count.zero? && @triggered_tools.empty?
+              log_tool_injection_skip(:no_settings_or_triggered_tools, settings_tool_count: settings_tool_count)
+              return false
+            end
+
+            true
+          end
+
+          def log_tool_injection_skip(reason, settings_tool_count: nil)
+            log.info(
+              "[llm][tools][inject] action=registry_skipped request_id=#{request_log_value(:id, 'unknown')} " \
+              "conversation_id=#{request_log_value(:conversation_id, 'none') || 'none'} reason=#{reason} " \
+              "settings_tools=#{settings_tool_count || 'unknown'} triggered_tools=#{@triggered_tools.size} " \
+              "requested_tools=#{requested_deferred_tool_names.size}"
+            )
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.log_tool_injection_skip')
+          end
+
+          def log_native_tool_definitions(definitions)
+            log.info(
+              "[llm][tools][inject] action=native_tool_definitions request_id=#{request_log_value(:id, 'unknown')} " \
+              "conversation_id=#{request_log_value(:conversation_id, 'none') || 'none'} provider=#{@resolved_provider || 'unknown'} " \
+              "model=#{@resolved_model || 'unknown'} total=#{definitions.size} sources=#{format_tool_source_counts(definitions)} " \
+              "client_request_tools=#{Array(request_log_value(:tools, [])).size} triggered_tools=#{@triggered_tools.size} " \
+              "requested_tools=#{requested_deferred_tool_names.size} names=#{format_tool_names(definitions.map(&:name))}"
+            )
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.log_native_tool_definitions')
+          end
+
+          def format_tool_source_counts(definitions)
+            counts = definitions.each_with_object(Hash.new(0)) do |definition, memo|
+              source = definition.respond_to?(:source) ? definition.source : {}
+              key = source.is_a?(Hash) ? (source[:type] || source['type'] || :unknown) : :unknown
+              memo[key] += 1
+            end
+            return 'none' if counts.empty?
+
+            counts.map { |key, count| "#{key}:#{count}" }.join(',')
+          end
+
+          def format_tool_names(names, limit = 30)
+            names = Array(names).map(&:to_s).reject(&:empty?)
+            return 'none' if names.empty?
+
+            visible = names.first(limit)
+            suffix = names.size > limit ? ",+#{names.size - limit}more" : ''
+            "#{visible.join(',')}#{suffix}"
+          end
+
+          def request_log_value(method_name, fallback)
+            @request.respond_to?(method_name) ? @request.public_send(method_name) : fallback
+          end
+
           def describe_tool_source(source)
             case source[:type]
             when :mcp

data/lib/legion/llm/metering.rb

@@ -142,26 +142,26 @@ module Legion
       def extract_usage(response)
         return { input_tokens: 0, output_tokens: 0 } unless response.is_a?(Hash)
 
-        usage = settings_value(response, :usage) || {}
+        usage = extract_hash_value(response, :usage) || {}
         {
-          input_tokens:  settings_value(usage, :input_tokens) || settings_value(usage, :prompt_tokens) || 0,
-          output_tokens: settings_value(usage, :output_tokens) || settings_value(usage, :completion_tokens) || 0
+          input_tokens:  extract_hash_value(usage, :input_tokens) || extract_hash_value(usage, :prompt_tokens) || 0,
+          output_tokens: extract_hash_value(usage, :output_tokens) || extract_hash_value(usage, :completion_tokens) || 0
         }
       end
 
       def extract_provider(response)
         return nil unless response.is_a?(Hash)
 
-        settings_value(settings_value(response, :meta), :provider) || settings_value(response, :provider)
+        extract_hash_value(extract_hash_value(response, :meta), :provider) || extract_hash_value(response, :provider)
       end
 
       def extract_model(response)
         return nil unless response.is_a?(Hash)
 
-        settings_value(settings_value(response, :meta), :model) || settings_value(response, :model)
+        extract_hash_value(extract_hash_value(response, :meta), :model) || extract_hash_value(response, :model)
       end
 
-      def settings_value(hash, key)
+      def extract_hash_value(hash, key)
         return nil unless hash.respond_to?(:key?)
 
         string_key = key.to_s

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.9.14'
+    VERSION = '0.9.17'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.9.14
+  version: 0.9.17
 platform: ruby
 authors:
 - Esity