legion-llm 0.7.8 → 0.7.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95918a13b81cc27203ad7eaccf52b06b7989735cb669febc7e94abd8c8c5452c
-  data.tar.gz: a7887cd39bbeda75313f37c134ef8461d7d6bd240be811dbf77e91f64343fc30
+  metadata.gz: 2e8391f38dbda2f0d629e206bb8844f50768d4200808b85e543f71115d639a65
+  data.tar.gz: ae14b4b492a61f8d626ae388ea819851372050df2ee78c7a37fd831e7e4d3fa4
 SHA512:
-  metadata.gz: e389df67e9855d573a195948123e6aae6760da6e461d54148edd0cd1faa8535445c744ce02b3512e89fd7603197370f4ea8d84bb9dd82588d3e545dea308bc2b
-  data.tar.gz: 965932e45bf5905b77ba667d43d24e70380a203b048f01daaa17cc72c835a952fd9ee474a78a868bd8fef538b1dca9843d599f13249cb88d7c67eca6b53fd64b
+  metadata.gz: 58253917894e86a8050b7655109a912ebec090cb6eb85607264d5b6a7927d8222bfb5de6e87689e7ce51e0679beb30af7c0e7375a477fca533605564706f6d2e
+  data.tar.gz: 3ae513c0ac3ffa347357be2ff50b8ee67ff2170ab416413855ce4f99e3558c17d7627365bf8e6cd4da579dd176d019163533db50ef255ad5f2f8a1504948e453

data/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## [Unreleased]
 
+## [0.7.15] - 2026-04-20
+
+### Added
+- PHI cloud provider gate: `compliance.phi_block_cloud` (default: `false`) blocks restricted-classified requests from cloud providers when enabled. Warns on permit when disabled. Cloud provider list configurable via `compliance.cloud_providers`. Fixes #72
+
+## [0.7.14] - 2026-04-20
+
+### Added
+- PII/PHI redaction mode: `compliance.redact_pii` (default: `false`) replaces detected patterns with configurable placeholder token before pipeline continues. Placeholder configurable via `compliance.redaction_placeholder` (default: `[REDACTED]`)
+- `compliance.strict_hipaa` setting (default: `false`): when enabled, scans all 12 HIPAA patterns; when disabled, scans only core 3 (SSN, email, phone) for lighter processing. Closes #73
+
+## [0.7.13] - 2026-04-20
+
+### Fixed
+- Classification step now always runs the PII/PHI scan, even on unclassified requests — defaults to `:public` baseline. Configurable via `compliance.default_level` (default: `:public`) and `compliance.classification_scan` (default: `true`). Fixes #70
+
+## [0.7.12] - 2026-04-20
+
+### Fixed
+- RBAC step now respects `rbac.fail_open` setting (default: `true`) when `Legion::Rbac` is unavailable. Fleet callers are always blocked. Non-fleet callers are permitted with a warning when `fail_open` is true, or blocked with 503 when false. Fixes #69
+
+## [0.7.11] - 2026-04-20
+
+### Fixed
+- RAG faithfulness check now logs a warning when RAG context is present but no `Hooks::RagGuard` is registered, instead of silently skipping. Fixes #71
+- RAG faithfulness failure now logs at warn level in addition to appending to pipeline warnings array
+
+## [0.7.10] - 2026-04-20
+
+### Fixed
+- `configure_anthropic` now passes `base_url` through to RubyLLM (`anthropic_api_base`) when present, enabling custom API gateways and proxies. Fixes #68
+- `configure_openai` now passes `base_url` through to RubyLLM (`openai_api_base`) when present, for consistency with Anthropic and Ollama providers
+- `configure_gemini` now passes `base_url` through to RubyLLM (`gemini_api_base`) when present, for consistency with Anthropic and Ollama providers
+
+## [0.7.9] - 2026-04-18
+### Added
+- Expanded PII/PHI classification to cover 12 HIPAA Safe Harbor identifier patterns (was 3) and 20 PHI keywords (was 11). Partial fix for #73
+
+### Fixed
+- `web_fetch` client tool now delegates to `Legion::CLI::Chat::WebFetch.fetch` instead of bare `Net::HTTP.get` — gains SSL, redirect following, HTML-to-markdown conversion, and `maxLength` truncation (LegionIO/LegionIO#153)
+- Added `web_search` client tool dispatch via `Legion::CLI::Chat::WebSearch.search` — previously fell through to generic "not executable server-side" error (LegionIO/LegionIO#154)
+
 ## [0.7.8] - 2026-04-17
 ### Fixed
 - Guard `Embeddings.generate` against providers that don't support embeddings before calling `RubyLLM.embed` — prevents noisy `NoMethodError: undefined method 'render_embedding_payload'` warns when Bedrock (or Anthropic) is the active provider

data/lib/legion/llm/pipeline/steps/classification.rb

@@ -11,27 +11,47 @@ module Legion
 
           LEVELS = %i[public internal confidential restricted].freeze
 
-          PII_PATTERNS = {
+          PII_PATTERNS_CORE = {
             ssn:   /\b\d{3}-\d{2}-\d{4}\b/,
             email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/,
             phone: /\b(?:\+?1[\s.-]?)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}\b/
           }.freeze
 
+          PII_PATTERNS_EXTENDED = {
+            ip_address:     /\b(?:\d{1,3}\.){3}\d{1,3}\b/,
+            date_of_birth:  %r{\b(?:0[1-9]|1[0-2])[/-](?:0[1-9]|[12]\d|3[01])[/-](?:19|20)\d{2}\b},
+            zip_code:       /\b\d{5}(?:-\d{4})?\b/,
+            mrn:            /\b(?:MRN|mrn)[:\s#]?\s?\d{4,12}\b/,
+            account_number: /\b(?:account|acct)[:\s#]?\s?\d{6,20}\b/i,
+            license_number: /\b[A-Z]\d{3,8}\b/,
+            url:            %r{\bhttps?://[^\s<>"']+}i,
+            vin:            /\b[A-HJ-NPR-Z0-9]{17}\b/,
+            npi_number:     /\b\d{10}\b/
+          }.freeze
+
+          PII_PATTERNS = PII_PATTERNS_CORE.merge(PII_PATTERNS_EXTENDED).freeze
+
           PHI_KEYWORDS = %w[
             patient diagnosis medication prescription
             dob date-of-birth mrn medical-record
-            npi clinical treatment
+            npi clinical treatment health-plan
+            beneficiary insurance-id group-number
+            lab-result radiology pathology
+            admission discharge procedure
           ].freeze
 
           def step_classification
-            return unless @request.classification || compliance_classification_default
+            classification = @request.classification || compliance_classification_default || default_classification
+            return unless classification_enabled?(classification)
 
-            classification  = @request.classification || compliance_classification_default
             declared_level  = classification[:level]
             scan            = scan_content_for_sensitive_data
             effective_level = upgrade_if_needed(declared_level, scan)
             upgraded        = effective_level != declared_level
 
+            redact_sensitive_content(scan)
+            enforce_phi_cloud_gate(effective_level)
+
             @enrichments['classification:scan'] = {
               declared_level:    declared_level,
               effective_level:   effective_level,
@@ -67,8 +87,9 @@ module Legion
           def scan_content_for_sensitive_data
             text     = extract_text_content
             patterns = []
+            active_patterns = strict_hipaa_mode? ? PII_PATTERNS : PII_PATTERNS_CORE
 
-            PII_PATTERNS.each do |name, regex|
+            active_patterns.each do |name, regex|
               patterns << name if text.match?(regex)
             end
 
@@ -76,12 +97,41 @@ module Legion
             patterns << :phi_keyword if phi_found
 
             {
-              contains_pii: patterns.intersect?(PII_PATTERNS.keys),
+              contains_pii: patterns.intersect?(active_patterns.keys),
               contains_phi: phi_found,
               patterns:     patterns
             }
           end
 
+          def redact_sensitive_content(scan)
+            return unless redaction_enabled?
+            return unless scan[:contains_pii] || scan[:contains_phi]
+
+            placeholder = redaction_placeholder
+            active_patterns = strict_hipaa_mode? ? PII_PATTERNS : PII_PATTERNS_CORE
+
+            @request.messages.each do |message|
+              next unless message[:content].is_a?(String)
+
+              active_patterns.each_value do |regex|
+                message[:content] = message[:content].gsub(regex, placeholder)
+              end
+
+              next unless scan[:contains_phi]
+
+              PHI_KEYWORDS.each do |kw|
+                message[:content] = message[:content].gsub(/\b#{Regexp.escape(kw)}\b/i, placeholder)
+              end
+            end
+
+            @enrichments['classification:redaction'] = {
+              redacted:          true,
+              patterns_redacted: scan[:patterns],
+              placeholder:       placeholder,
+              timestamp:         Time.now
+            }
+          end
+
           def extract_text_content
             @request.messages.map { |m| m[:content].to_s }.join(' ')
           end
@@ -97,6 +147,28 @@ module Legion
             LEVELS[threshold_idx]
           end
 
+          def default_classification
+            { level: default_classification_level }
+          end
+
+          def default_classification_level
+            return :public unless defined?(Legion::Settings)
+
+            level = Legion::Settings.dig(:compliance, :default_level)
+            level ? level.to_sym : :public
+          rescue StandardError
+            :public
+          end
+
+          def classification_enabled?(_classification)
+            return true unless defined?(Legion::Settings)
+
+            enabled = Legion::Settings.dig(:compliance, :classification_scan)
+            enabled.nil? || enabled
+          rescue StandardError
+            true
+          end
+
           def compliance_classification_default
             return nil unless defined?(Legion::Settings)
 
@@ -108,6 +180,73 @@ module Legion
             handle_exception(e, level: :warn, operation: 'llm.pipeline.steps.classification.default')
             nil
           end
+
+          def redaction_enabled?
+            setting = Legion::Settings.dig(:compliance, :redact_pii)
+            setting == true
+          rescue StandardError
+            false
+          end
+
+          def strict_hipaa_mode?
+            setting = Legion::Settings.dig(:compliance, :strict_hipaa)
+            setting == true
+          rescue StandardError
+            false
+          end
+
+          def redaction_placeholder
+            Legion::Settings.dig(:compliance, :redaction_placeholder) || '[REDACTED]'
+          rescue StandardError
+            '[REDACTED]'
+          end
+
+          def enforce_phi_cloud_gate(effective_level)
+            return unless effective_level == :restricted
+
+            provider = resolve_current_provider
+            return unless cloud_provider?(provider)
+
+            if phi_block_cloud?
+              raise Legion::LLM::PipelineError.new(
+                "Restricted/sensitive content (level=restricted) cannot be sent to cloud provider #{provider}. " \
+                'Set compliance.phi_block_cloud=false to override, or use a local provider.',
+                step: :classification
+              )
+            end
+
+            log.warn(
+              "[classification] Restricted/sensitive content (level=restricted) routing to cloud provider #{provider} — " \
+              'compliance.phi_block_cloud is disabled, permitting'
+            )
+            @warnings << "Restricted/sensitive content routing to cloud provider #{provider} (phi_block_cloud disabled)"
+          end
+
+          def phi_block_cloud?
+            setting = Legion::Settings.dig(:compliance, :phi_block_cloud)
+            setting == true
+          rescue StandardError
+            false
+          end
+
+          def cloud_provider?(provider)
+            return false unless provider
+
+            cloud_providers = Legion::Settings.dig(:compliance, :cloud_providers) ||
+                              %i[anthropic openai gemini bedrock azure]
+            cloud_providers.map(&:to_sym).include?(provider.to_sym)
+          rescue StandardError
+            false
+          end
+
+          def resolve_current_provider
+            routing = @request.respond_to?(:routing) ? @request.routing : nil
+            provider = routing[:provider] if routing.is_a?(Hash)
+            provider ||= Legion::Settings.dig(:llm, :default_provider)
+            provider&.to_sym
+          rescue StandardError
+            nil
+          end
         end
       end
     end

data/lib/legion/llm/pipeline/steps/rag_guard.rb

@@ -12,7 +12,11 @@ module Legion
           def check_rag_faithfulness
             context = @enrichments.dig('rag:context_retrieval', :data, :entries)
             return unless context&.any?
-            return unless defined?(Hooks::RagGuard)
+
+            unless defined?(Hooks::RagGuard)
+              log.warn('[rag_guard] RAG context present but no Hooks::RagGuard registered — faithfulness check skipped')
+              return
+            end
 
             response_text = @raw_response.respond_to?(:content) ? @raw_response.content : @raw_response.to_s
 
@@ -25,6 +29,7 @@ module Legion
             return if result.nil? || result[:faithful]
 
             detail = result[:details] || result[:reason] || 'faithfulness check failed'
+            log.warn("[rag_guard] RAG faithfulness warning: #{detail}")
             @warnings << "RAG faithfulness warning: #{detail}"
             @timeline.record(
               category: :quality, key: 'rag:faithfulness_warning',

data/lib/legion/llm/pipeline/steps/rbac.rb

@@ -13,18 +13,21 @@ module Legion
             start_time = Time.now
 
             unless defined?(::Legion::Rbac)
-              if fleet_caller?
-                msg = 'RBAC unavailable: fleet callers require RBAC enforcement (fail-closed)'
-                log.error("[llm][rbac] fleet_blocked request_id=#{@request.id} reason=rbac_unavailable")
+              if fleet_caller? || !fail_open_permitted?
+                msg = '503: RBAC unavailable — request denied ' \
+                      "(fleet=#{fleet_caller?}, fail_open=#{fail_open_permitted?})"
+                log.error("[llm][rbac] blocked request_id=#{@request.id} reason=rbac_unavailable " \
+                          "fleet=#{fleet_caller?} fail_open=#{fail_open_permitted?}")
                 record_rbac_audit(:failure, msg, start_time)
                 record_rbac_timeline("denied: #{msg}")
-                raise Legion::LLM::PipelineError.new("403 Forbidden: #{msg}", step: :rbac)
+                raise Legion::LLM::PipelineError.new(msg, step: :rbac)
               end
 
-              @warnings << 'RBAC unavailable, permitting request without enforcement'
-              log.info("[llm][rbac] unavailable request_id=#{@request.id} action=permit_without_enforcement")
-              record_rbac_audit(:success, 'permitted (rbac unavailable)', start_time)
-              record_rbac_timeline('permitted (rbac unavailable)')
+              log.warn('[llm][rbac] RBAC unavailable, permitting request (fail_open enabled) ' \
+                       "request_id=#{@request.id}")
+              @warnings << 'RBAC unavailable, permitting request (fail_open enabled)'
+              record_rbac_audit(:success, 'permitted (rbac unavailable, fail_open enabled)', start_time)
+              record_rbac_timeline('permitted (rbac unavailable, fail_open enabled)')
               return
             end
 
@@ -54,6 +57,11 @@ module Legion
 
           private
 
+          def fail_open_permitted?
+            setting = Legion::Settings.dig(:rbac, :fail_open)
+            setting.nil? || setting
+          end
+
           def build_rbac_principal
             rb = @request.caller&.fetch(:requested_by, {}) || {}
             ::Legion::Rbac::Principal.new(

data/lib/legion/llm/providers.rb

@@ -111,8 +111,9 @@ module Legion
 
         RubyLLM.configure do |c|
           c.anthropic_api_key = api_key
+          c.anthropic_api_base = config[:base_url] if config[:base_url]
         end
-        log.info 'Configured Anthropic provider'
+        log.info "Configured Anthropic provider#{" (#{config[:base_url]})" if config[:base_url]}"
       end
 
       def configure_openai(config)
@@ -121,8 +122,9 @@ module Legion
 
         RubyLLM.configure do |c|
           c.openai_api_key = api_key
+          c.openai_api_base = config[:base_url] if config[:base_url]
         end
-        log.info 'Configured OpenAI provider'
+        log.info "Configured OpenAI provider#{" (#{config[:base_url]})" if config[:base_url]}"
       end
 
       def configure_gemini(config)
@@ -131,8 +133,9 @@ module Legion
 
         RubyLLM.configure do |c|
           c.gemini_api_key = api_key
+          c.gemini_api_base = config[:base_url] if config[:base_url]
         end
-        log.info 'Configured Gemini provider'
+        log.info "Configured Gemini provider#{" (#{config[:base_url]})" if config[:base_url]}"
       end
 
       def configure_azure(config)

data/lib/legion/llm/routes.rb

@@ -46,7 +46,7 @@ module Legion
           end
         end
 
-        def dispatch_client_tool(ref, **kwargs)
+        def dispatch_client_tool(ref, **kwargs) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
           case ref
           when 'sh'
             cmd = kwargs[:command] || kwargs[:cmd] || kwargs.values.first.to_s
@@ -81,9 +81,27 @@ module Legion
             Dir.glob(pattern).first(100).join("\n")
           when 'web_fetch'
             url = kwargs[:url] || kwargs.values.first.to_s
-            require 'net/http'
-            uri = URI(url)
-            Net::HTTP.get(uri)
+            raw_max_length = kwargs[:maxLength] || kwargs[:max_length]
+            max_length = raw_max_length.nil? ? nil : [raw_max_length.to_i, 0].max
+            begin
+              require 'legion/cli/chat/web_fetch'
+              content = Legion::CLI::Chat::WebFetch.fetch(url)
+              max_length ? content[0, max_length] : content
+            rescue LoadError => e
+              missing = e.respond_to?(:path) && e.path ? e.path : 'legion/cli/chat/web_fetch'
+              "web_fetch is unavailable: missing optional dependency #{missing}"
+            end
+          when 'web_search'
+            query = kwargs[:query] || kwargs.values.first.to_s
+            max_results = (kwargs[:max_results] || kwargs[:maxResults] || 5).to_i
+            begin
+              require 'legion/cli/chat/web_search'
+              results = Legion::CLI::Chat::WebSearch.search(query, max_results: max_results, auto_fetch: false)
+              results[:results].map { |r| "### #{r[:title]}\n#{r[:url]}\n#{r[:snippet]}" }.join("\n\n")
+            rescue LoadError => e
+              missing = e.respond_to?(:path) && e.path ? e.path : 'legion/cli/chat/web_search'
+              "web_search is unavailable: missing optional dependency #{missing}"
+            end
           else
             "Tool #{ref} is not executable server-side. Use a legion_ prefixed tool instead."
           end

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.7.8'
+    VERSION = '0.7.15'
   end
 end

metadata

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