legion-llm 0.8.15 → 0.8.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d36acc38aded21eee645009a3bf41e8a0214aff728ee3179becbede3bc70528
-  data.tar.gz: 301984dc9000a53f88036fb5672faf616b0cc1d45c898462999133e976555d51
+  metadata.gz: 1106f652c69b801af983117b4fc97f6bf547dc4d63f1b1df12eb6f1adb6d51d2
+  data.tar.gz: '00593f91f0467fd63e5a8867017033da483bf0abc4fcfa26641fe97fd66c3674'
 SHA512:
-  metadata.gz: 49c479b427f77ee4aa0b1c59f9fca8fa3d9947f68ebc05de298158766744b1c2877696603c97baf82be7144d2f97c6d23cd3d0856358316ac4fddf908a7561c2
-  data.tar.gz: 84e6095b475be225de975deac022a7587af8f9a4cae13950a85be9149803bed8dc689cf2cacb0f6d5abc5114edacc8eb8f94df66e23f76f09cd98ebc3a014d51
+  metadata.gz: 30c59046ad40659fa02f3bde8db8807b3a9c3b718365dc1be5d92ca01c9cb84e593c4bcab5027f12a591ee12c3f21671ae3695573f5e85b3c5e9d8b7b1ebf74b
+  data.tar.gz: 91368ea195a58f8321cca378febcca27a96685a6a1fe78ac432be88731ee03a4ca050b1782f8d1f24da6045b5f136ea070ee14fd4dbb2eb28e23c8db63f28174

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Legion LLM Changelog
 
+## [0.8.18] - 2026-04-22
+
+### Fixed
+- API caller identity no longer hardcoded as `api:inference`. The inference route now resolves the actual user via `env['legion.principal']` (from Identity::Middleware), `Legion::Identity::Process` (LDAP/Kerberos), or OS username (with email domain stripped). Adds `username` and `hostname` to the `requested_by` hash in audit trails.
+
+## [0.8.17] - 2026-04-22
+
+### Added
+- Audit events now include `system_prompt` (full text sent to provider), `injected_tools` (list of tool names injected), and `identity` (extracted user identity from caller).
+
+### Fixed
+- `tokens` field in audit events was serialized as a `#<data ...>` inspect string instead of a proper hash. Now calls `.to_h` on Data.define objects.
+- `enrichments` in audit events now compacted: array values (e.g. GAIA valence history) reduced to their last element.
+- `timeline` in audit events filtered to only provider, escalation, and tool execution events — diagnostic trace entries (tracing:init, rbac, context:stored, etc.) are stripped.
+
+## [0.8.16] - 2026-04-22
+
+### Fixed
+- `RubyLLM::BadRequestError` (HTTP 400) and `RubyLLM::ContextLengthExceededError` now trigger the provider fallback-retry chain instead of bubbling up as unhandled 500s. Both `run_provider_call_single` and `step_provider_call_stream` retry on the next available provider before giving up.
+- Resolved provider/model is now logged (`log.info`) in `step_routing` so provider errors can be diagnosed from daemon logs without relying on SSE done events.
+
+### Changed
+- Extracted `try_fallback_or_raise` helper from duplicated retry logic in both rescue chains, reducing the auth/bad-request/context-overflow fallback pattern to a single call each.
+
+## [0.8.15] - 2026-04-22
+
+### Changed
+- **5-tier routing model**: restructured from 3 tiers (local/fleet/cloud) to 5 tiers (local/fleet/openai_compat/cloud/frontier). Anthropic and OpenAI are now `:frontier` (direct API); Bedrock, Azure, Gemini are `:cloud` (managed providers). New `:openai_compat` tier for user-configured OpenAI-spec gateways.
+- `Resolution`: added `frontier?`, `openai_compat?`, and `external?` predicates.
+- `TierAssigner`: `user:*` and critical/high priority requests route to `:frontier` instead of `:cloud`.
+- `GatewayInterceptor`: intercepts both `:cloud` and `:frontier` tiers, preserving original tier.
+- Privacy enforcement (`assert_external_allowed!`) blocks all external tiers (cloud + frontier + openai_compat), not just cloud. `never_cloud` constraint now blocks both `:cloud` and `:frontier`. New `never_external` constraint blocks all three external tiers.
+- `resolve_chain` fallback defaults changed from `:cloud`/`:bedrock` to `:frontier`/`:anthropic`.
+
 ## [0.8.13] - 2026-04-22
 
 ### Fixed

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

@@ -326,6 +326,58 @@ module Legion
                 end
               end
 
+              define_method(:resolve_caller_identity) do |rack_env|
+                return rack_env['legion.tenant_id'] if rack_env['legion.tenant_id']
+
+                kerb = begin
+                  Legion::Settings.dig(:kerberos, :username)
+                rescue StandardError
+                  nil
+                end
+                return "user:#{kerb}" if kerb.is_a?(String) && !kerb.empty?
+
+                principal = rack_env['legion.principal']
+                return "user:#{principal.canonical_name}" if principal.respond_to?(:canonical_name) && principal.canonical_name != 'system'
+
+                if defined?(Legion::Identity::Process)
+                  name = Legion::Identity::Process.canonical_name
+                  return "user:#{name}" if name && name != 'anonymous'
+                end
+
+                raw = ENV.fetch('USER', nil) || ENV.fetch('LOGNAME', nil) || 'anonymous'
+                username = raw.include?('@') ? raw.split('@').first : raw
+                "user:#{username}"
+              end
+
+              define_method(:resolve_requested_by) do |rack_env, identity_string|
+                hostname = begin
+                  Legion::Settings[:client][:hostname]
+                rescue StandardError
+                  Socket.gethostname
+                end
+                username = identity_string.delete_prefix('user:')
+
+                kerb = begin
+                  Legion::Settings.dig(:kerberos, :username)
+                rescue StandardError
+                  nil
+                end
+                if kerb.is_a?(String) && !kerb.empty?
+                  return { identity: identity_string, type: :user, credential: :kerberos,
+                           username: kerb, hostname: hostname }
+                end
+
+                principal = rack_env['legion.principal']
+                if principal.respond_to?(:canonical_name) && principal.canonical_name != 'system'
+                  return { identity: identity_string, type: principal.kind || :user,
+                           credential: principal.source || :local,
+                           username: principal.canonical_name, hostname: hostname }
+                end
+
+                { identity: identity_string, type: :user, credential: :local,
+                  username: username, hostname: hostname }
+              end
+
               define_method(:token_value) do |tokens, key|
                 return nil if tokens.nil?
                 return tokens[key] || tokens[key.to_s] if tokens.is_a?(Hash)

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

@@ -42,7 +42,7 @@ module Legion
               tools = raw_tools || []
               validate_tools!(tools) unless tools.empty?
 
-              caller_identity = env['legion.tenant_id'] || 'api:inference'
+              caller_identity = resolve_caller_identity(env)
               last_user = messages.select { |m| (m[:role] || m['role']).to_s == 'user' }.last
               prompt    = (last_user || {})[:content] || (last_user || {})['content'] || ''
 
@@ -79,7 +79,7 @@ module Legion
               server_caller_fields = {
                 source:       'api',
                 path:         request.path,
-                requested_by: { identity: caller_identity, type: :user, credential: :api }
+                requested_by: resolve_requested_by(env, caller_identity)
               }
               effective_caller = server_caller_fields.merge(safe_caller_fields)
               caller_summary = [effective_caller[:source], effective_caller[:path]].compact.join(':')

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

@@ -22,17 +22,22 @@ module Legion
             tc.is_a?(Types::ToolCall) ? tc.to_audit_hash : tc
           end
 
+          audit_data = response.audit || {}
+          provider_payload = audit_data[:provider_payload] || {}
+
           event = {
             request_id:       response.request_id,
             conversation_id:  response.conversation_id,
             caller:           response.caller,
+            identity:         extract_identity(response.caller),
             routing:          response.routing,
-            tokens:           response.tokens,
+            tokens:           serialize_tokens(response.tokens),
             cost:             response.cost,
-            enrichments:      response.enrichments,
-            audit:            response.audit,
-            timeline:         response.timeline,
-            timestamps:       response.timestamps,
+            system_prompt:    provider_payload[:system_prompt],
+            injected_tools:   provider_payload[:injected_tools],
+            enrichments:      compact_enrichments(response.enrichments),
+            audit:            audit_data.except(:provider_payload),
+            timeline:         compact_timeline(response.timeline),
             classification:   response.classification,
             tracing:          response.tracing,
             messages:         request.messages,
@@ -58,6 +63,52 @@ module Legion
           nil
         end
 
+        def extract_identity(caller)
+          return nil unless caller.is_a?(Hash)
+
+          rb = caller[:requested_by] || caller['requested_by']
+          return nil unless rb.is_a?(Hash)
+
+          {
+            identity:   rb[:identity] || rb['identity'],
+            type:       rb[:type] || rb['type'],
+            credential: rb[:credential] || rb['credential']
+          }.compact
+        end
+
+        def serialize_tokens(tokens)
+          return tokens.to_h if tokens.respond_to?(:to_h) && !tokens.is_a?(Hash)
+          return tokens if tokens.is_a?(Hash)
+
+          {}
+        end
+
+        def compact_enrichments(enrichments)
+          return {} unless enrichments.is_a?(Hash)
+
+          enrichments.transform_values do |v|
+            next v unless v.is_a?(Hash)
+
+            summary = { content: v[:content], timestamp: v[:timestamp] }
+            data = v[:data]
+            next summary unless data.is_a?(Hash)
+
+            compacted = data.transform_values do |dv|
+              dv.is_a?(Array) && dv.size > 1 ? dv.last : dv
+            end
+            summary.merge(data: compacted)
+          end
+        end
+
+        def compact_timeline(timeline)
+          return [] unless timeline.is_a?(Array)
+
+          timeline.select do |event|
+            key = (event[:key] || event['key']).to_s
+            key.start_with?('provider:') || key.start_with?('escalation:') || key.start_with?('tool:execute:')
+          end
+        end
+
         def build_message_context(response:, **)
           {
             request_id:      response.request_id,

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

@@ -331,6 +331,7 @@ module Legion
           @resolved_provider = provider || Legion::LLM.settings[:default_provider]
           @resolved_model = model || Legion::LLM.settings[:default_model]
 
+          log.info "[llm][inference] resolved provider=#{@resolved_provider} model=#{@resolved_model}"
           @timeline.record(
             category: :audit, key: 'routing:provider_selection',
             direction: :internal, detail: "routed to #{@resolved_provider}:#{@resolved_model}",
@@ -356,38 +357,17 @@ module Legion
             execute_provider_request
           rescue RubyLLM::UnauthorizedError, RubyLLM::ForbiddenError,
                  Faraday::UnauthorizedError, Faraday::ForbiddenError => e
-            providers_tried << @resolved_provider
-            fallback = find_fallback_provider(exclude: providers_tried)
-            handle_exception(
-              e,
-              level:             :warn,
-              operation:         'llm.pipeline.provider_call.auth',
-              provider:          @resolved_provider,
-              model:             @resolved_model,
-              fallback_provider: fallback&.dig(:provider)
-            )
-            if fallback
-              log.warn "[pipeline] #{@resolved_provider} auth failed (#{e.class}), falling back to #{fallback[:provider]}:#{fallback[:model]}"
-              from_provider = @resolved_provider
-              from_model = @resolved_model
-              @resolved_provider = fallback[:provider]
-              @resolved_model = fallback[:model]
-              @warnings << { type: :provider_fallback, original_error: e.message, fallback: "#{@resolved_provider}:#{@resolved_model}" }
-              @tool_event_handler&.call(
-                type: :model_fallback,
-                from_provider: from_provider, to_provider: @resolved_provider,
-                from_model: from_model, to_model: @resolved_model,
-                error: e.message, reason: 'auth_failed'
-              )
-              @timeline.record(
-                category: :provider, key: 'provider:fallback',
-                direction: :internal,
-                detail: "auth failed on #{providers_tried.last}, trying #{@resolved_provider}",
-                from: 'pipeline', to: "provider:#{@resolved_provider}"
-              )
-              retry
-            end
-            raise Legion::LLM::AuthError, e.message
+            try_fallback_or_raise(e, providers_tried, operation: 'provider_call.auth',
+                                                      reason: 'auth_failed', error_class: Legion::LLM::AuthError)
+            retry
+          rescue RubyLLM::ContextLengthExceededError => e
+            try_fallback_or_raise(e, providers_tried, operation: 'provider_call.context_overflow',
+                                                      reason: 'context_overflow', error_class: Legion::LLM::ContextOverflow)
+            retry
+          rescue RubyLLM::BadRequestError => e
+            try_fallback_or_raise(e, providers_tried, operation: 'provider_call.bad_request',
+                                                      reason: 'bad_request', error_class: Legion::LLM::ProviderError)
+            retry
           rescue RubyLLM::RateLimitError => e
             handle_exception(e, level: :warn, operation: 'llm.pipeline.provider_call.rate_limit',
                               provider: @resolved_provider, model: @resolved_model)
@@ -651,33 +631,17 @@ module Legion
             execute_provider_request_stream(&)
           rescue RubyLLM::UnauthorizedError, RubyLLM::ForbiddenError,
                  Faraday::UnauthorizedError, Faraday::ForbiddenError => e
-            providers_tried << @resolved_provider
-            fallback = find_fallback_provider(exclude: providers_tried)
-            handle_exception(
-              e,
-              level:             :warn,
-              operation:         'llm.pipeline.provider_call_stream.auth',
-              provider:          @resolved_provider,
-              model:             @resolved_model,
-              fallback_provider: fallback&.dig(:provider)
-            )
-            if fallback
-              log.warn "[pipeline] #{@resolved_provider} stream auth failed (#{e.class}), " \
-                       "falling back to #{fallback[:provider]}:#{fallback[:model]}"
-              from_provider = @resolved_provider
-              from_model = @resolved_model
-              @resolved_provider = fallback[:provider]
-              @resolved_model = fallback[:model]
-              @warnings << { type: :provider_fallback, original_error: e.message, fallback: "#{@resolved_provider}:#{@resolved_model}" }
-              @tool_event_handler&.call(
-                type: :model_fallback,
-                from_provider: from_provider, to_provider: @resolved_provider,
-                from_model: from_model, to_model: @resolved_model,
-                error: e.message, reason: 'auth_failed'
-              )
-              retry
-            end
-            raise Legion::LLM::AuthError, e.message
+            try_fallback_or_raise(e, providers_tried, operation: 'provider_call_stream.auth',
+                                                      reason: 'auth_failed', error_class: Legion::LLM::AuthError)
+            retry
+          rescue RubyLLM::ContextLengthExceededError => e
+            try_fallback_or_raise(e, providers_tried, operation: 'provider_call_stream.context_overflow',
+                                                      reason: 'context_overflow', error_class: Legion::LLM::ContextOverflow)
+            retry
+          rescue RubyLLM::BadRequestError => e
+            try_fallback_or_raise(e, providers_tried, operation: 'provider_call_stream.bad_request',
+                                                      reason: 'bad_request', error_class: Legion::LLM::ProviderError)
+            retry
           rescue RubyLLM::RateLimitError => e
             handle_exception(e, level: :warn, operation: 'llm.pipeline.provider_call_stream.rate_limit',
                               provider: @resolved_provider, model: @resolved_model)
@@ -728,7 +692,14 @@ module Legion
           session = RubyLLM.chat(**ruby_llm_chat_options)
 
           inject_ruby_llm_tools(session)
-          apply_ruby_llm_instructions(session)
+          system_prompt = apply_ruby_llm_instructions(session)
+
+          @audit[:provider_payload] = {
+            system_prompt:  system_prompt,
+            injected_tools: @injected_tool_map.keys,
+            tool_count:     @injected_tool_map.size,
+            timestamp:      Time.now
+          }
 
           messages = apply_conversation_breakpoint(@request.messages)
           add_ruby_llm_prior_messages(session, messages)
@@ -887,10 +858,12 @@ module Legion
             system:      @request.system,
             enrichments: @enrichments
           )
-          return unless injected_system
+          return nil unless injected_system
 
           system_blocks = apply_cache_control([{ type: :text, content: injected_system }])
-          session.with_instructions(system_blocks.last[:content])
+          final = system_blocks.last[:content]
+          session.with_instructions(final)
+          final
         end
 
         def add_ruby_llm_prior_messages(session, messages)
@@ -967,6 +940,33 @@ module Legion
           nil
         end
 
+        def try_fallback_or_raise(error, providers_tried, operation:, reason:, error_class:)
+          providers_tried << @resolved_provider
+          fallback = find_fallback_provider(exclude: providers_tried)
+          handle_exception(
+            error,
+            level: :warn, operation: "llm.pipeline.#{operation}",
+            provider: @resolved_provider, model: @resolved_model,
+            fallback_provider: fallback&.dig(:provider)
+          )
+          raise error_class, "#{@resolved_provider}:#{@resolved_model} #{reason} — #{error.message}" unless fallback
+
+          log.warn "[pipeline] #{@resolved_provider}:#{@resolved_model} #{reason} (#{error.message}), " \
+                   "falling back to #{fallback[:provider]}:#{fallback[:model]}"
+          from_provider = @resolved_provider
+          from_model = @resolved_model
+          @resolved_provider = fallback[:provider]
+          @resolved_model = fallback[:model]
+          @warnings << { type: :provider_fallback, original_error: error.message,
+                         fallback: "#{@resolved_provider}:#{@resolved_model}" }
+          @tool_event_handler&.call(
+            type: :model_fallback,
+            from_provider: from_provider, to_provider: @resolved_provider,
+            from_model: from_model, to_model: @resolved_model,
+            error: error.message, reason: reason
+          )
+        end
+
         def find_fallback_provider(exclude: [])
           providers = Legion::LLM.settings[:providers] || {}
           providers.each do |name, config|

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.8.15'
+    VERSION = '0.8.18'
   end
 end

metadata

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