olyx-guardrails 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1ee4f7c6297bf8348c6d74feff8bd055ce23b819091893043d02a6695140cd2
-  data.tar.gz: e06e7f54f777a8e56da1fcbad45f92d327f30aea934467235a9bc4384dc2229d
+  metadata.gz: 196f3e181407760bea2e26500d3e3eaa5ce29b886922ad361eab20e98ea76b68
+  data.tar.gz: 24144315dc438469cc42ca4d876834b44c3ad3b1b42430a80d6bc693e57ceec3
 SHA512:
-  metadata.gz: 1d85a8e9c03dc058fd188132a2754c4738063ddc79039eb5bd88c5dcf25555f3b266d6d4b29ee37503b7c25fe0beabc74d0cfe895f82ad16c82e93ff2351955b
-  data.tar.gz: 6e04d4fda8672b775475e0741b621ee850ab178656283a20c4fc1f27aa324112cb2ee5c883890dec97b53d423b7f65e6daa88006269574481c36e69128542afd
+  metadata.gz: e3ecc41c16b5f43dc99beb1af720a1f5f0a4f68fbb5453504a21e01c14ff7f1c248e724bd7987e5e4db50aa15944cf03291556a41c951282b98351eb863e1512
+  data.tar.gz: 8814874a0d9f40c93a6deb3b2063da29378f6a149742319f19b9b6aa7a50142e52937baab9cc71e6ae58706d42a65820467391d8a583eae021f7d1cad7665b1f

data/CHANGELOG.md

@@ -5,24 +5,28 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.2.1] - 2026-11-11
+
+### Changed
+
+- Simplify evaluation, message handling, LLM analysis, and numeric date validation
+  while preserving the public result contract.
+- Require patched Rails test bundles: 8.1.4.1 or newer on Rails 8.1 and
+  8.0.5.2 or newer on Rails 8.0, with Rack >= 3.2.8 and Crass >= 1.0.8.
+- Document request-body limits, host allowlists, and trusted proxy headers for
+  applications consuming the gem.
+
 ## [1.2.0] - 2026-10-02
 
 ### Changed
 
-- Prompt-injection normalization now scans long inputs in overlapping bounded
-  windows instead of ignoring content after the first 20,000 characters.
-- Narrowed role-play matching so ordinary agent prompts do not block by
-  default.
-- Provider exceptions return a stable public error instead of exposing the
-  provider's exception message.
-- Confidentiality labels are no longer classified as credentials or used to
-  redact an entire input. Applications can enforce those labels with policy
-  rules when required.
-- Risk scores now describe findings independently from the policy's blocking
-  configuration.
-- Removed redundant scanner passes and consolidated internal configuration and
-  matching layers.
-- Simplified the public quality gate to tests, documentation, and RuboCop.
+- Scans long inputs in overlapping windows and narrows injection matching to
+  reduce missed detections and false positives.
+- Sanitizes provider failures and stops treating confidentiality labels as
+  credentials; applications can enforce those labels with policy rules.
+- Reports risk independently from blocking policy.
+- Consolidates scanning and configuration internals, with tests,
+  documentation, and RuboCop as the public quality gate.
 
 ## [1.1.3] - 2026-08-07
 

data/README.md

@@ -6,61 +6,43 @@
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/Olyx-labs/olyx-guardrails/badge)](https://securityscorecards.dev/viewer/?uri=github.com/Olyx-labs/olyx-guardrails)
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 
-Olyx Guardrails is an in-process safety boundary for Ruby and Rails
-applications that send or receive AI-generated content. It provides:
+Input and output checks for AI applications in Ruby and Rails.
 
-- PII and secret detection with explicit redaction;
-- prompt-injection and jailbreak detection, including adjacent-turn checks;
-- immutable, organization-specific restricted-content policies;
-- completed-input and completed-output decisions;
-- opt-in Rails adapters for common ingestion paths;
-- provider-agnostic semantic analysis through a callable LLM hook; and
-- sanitized notifications and Active Support instrumentation.
+Detect prompt injection, PII, secrets, and application-specific restricted
+content. Return explicit allow/block decisions and redact recognized content
+at the boundaries your application chooses.
 
-The deterministic checks run locally. The gem does not proxy model traffic,
-discover model calls, or send application content to a third party.
+Olyx Guardrails is a standalone gem. It works without Olyx CLI, Olyx Cloud,
+or an Olyx account. Deterministic checks run locally. An optional
+`llm_provider` receives raw input and may send it elsewhere through your
+application's adapter.
 
-## Requirements
+## Install
 
-| Component | Supported versions |
-|---|---|
-| Ruby | 3.4 or newer |
-| Rails | 8.0 and 8.1 |
+Requires **Ruby 3.4 or newer**. Rails is optional; the integration supports
+**Rails 8.0 and 8.1**. The framework-free API does not load Rails.
 
-Rails is optional. The standalone Ruby API does not load Rails.
-
-The 1.1 release line supports Rails 8.0 and 8.1. Only the listed Rails
-series are tested and supported. When a series reaches upstream end-of-life,
-a subsequent gem release may remove it instead of maintaining framework
-security fixes independently. Every support change is recorded in the
-changelog.
-
-## Installation
-
-Add the gem to the application:
+Add to your `Gemfile`:
 
 ```ruby
-gem "olyx-guardrails", "~> 1.1"
+gem "olyx-guardrails", "~> 1.2"
 ```
 
-Then install the bundle:
-
-```bash
+```sh
 bundle install
 ```
 
-The only runtime gem dependency is Ruby's `base64` bundled gem, used for
-bounded encoded-input detection.
+The only runtime gem dependency is Ruby's bundled `base64` gem.
 
-## Quick start
+## Try it
 
-Create one immutable policy and use it at the application boundary:
+Save this as `guardrails_example.rb`:
 
 ```ruby
 require "olyx/guardrails"
 
 policy = Olyx::Guardrails::Policy.new(
-  name: "customer-data-boundary",
+  name: "application-boundary",
   max_input_length: 4_000,
   block_pii: false,
   block_injections: true,
@@ -76,198 +58,147 @@ policy = Olyx::Guardrails::Policy.new(
   ]
 )
 
+input = "Contact ada@example.com about the release."
 decision = Olyx::Guardrails.check(input, policy: policy)
-return forbidden unless decision[:allowed]
+abort "Input rejected" unless decision[:allowed]
 
-safe_input = Olyx::Guardrails.redact(input, policy: policy)[:text]
-completion = LlmClient.complete(safe_input)
+puts "Allowed: #{decision[:allowed]}"
+puts Olyx::Guardrails.redact(input, policy: policy)[:text]
 
-output_decision = Olyx::Guardrails.check_output(completion, policy: policy)
-return invalid_output unless output_decision[:allowed]
+restricted = Olyx::Guardrails.check("Discuss Project Falcon", policy: policy)
+puts "Restricted input allowed: #{restricted[:allowed]}"
 ```
 
-`check` makes a decision and never transforms input. `redact` transforms
-recognized content and never makes an allow/block decision. Applications that
-need both operations call both explicitly.
+Run it:
 
-The default policy:
+```sh
+bundle exec ruby guardrails_example.rb
+```
 
-- limits input to 10,000 characters;
-- blocks detected injection attempts;
-- reports, but does not block, detected PII and secrets; and
-- has no custom restricted-content rules.
+Expected output:
 
-Production applications should construct an explicit policy instead of relying
-on defaults. See the
-[Policies guide](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/POLICIES.md)
-for the complete rule language and YAML examples.
+```text
+Allowed: true
+Contact [EMAIL] about the release.
+Restricted input allowed: false
+```
 
-## Rails quick start
+In this policy, PII is reported without blocking, then explicitly redacted.
+Injection attempts, secrets, and the configured project name cause rejection.
+Policies are immutable: construct them once and reuse them.
+
+**Checking and redacting are separate operations.** `check` returns a decision
+without changing input. `redact` transforms recognized content without making
+an allow/block decision. Redaction does not override a rejection.
+
+Use `check_messages` for structured conversations and adjacent-turn detection.
+Use `check_output` and `redact_output` at completed-output boundaries. Your
+application owns the model call and must check the completed response before
+returning it. See the [complete Ruby example](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/ruby_only.rb) and
+[API reference](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/API.md) for the full flow and result contracts.
+
+## Add Rails enforcement
 
 Generate an initializer and environment-keyed policy file:
 
-```bash
+```sh
 bin/rails generate olyx_guardrails:install
 ```
 
-Add the controller concern only where content crosses an AI boundary:
+Review `config/initializers/olyx_guardrails.rb` and
+`config/olyx_guardrails.yml`, then include an adapter at an application boundary:
 
 ```ruby
 class AiRequestsController < ApplicationController
   include Olyx::Guardrails::Rails::Controller
 
   rescue_from Olyx::Guardrails::Blocked do |error|
-    render json: {
-      error: "input_rejected",
-      decision: error.decision
-    }, status: :unprocessable_entity
+    render json: { error: "input_rejected", decision: error.decision },
+           status: :unprocessable_entity
   end
 
   def create
     prompt = params.require(:prompt)
-    guardrails_check!(prompt, metadata: { user_id: current_user.id })
-
+    guardrails_check!(prompt)
     safe_prompt = guardrails_redact(prompt)[:text]
+
     completion = LlmClient.complete(safe_prompt)
     Olyx::Guardrails::Rails::Enforcer.check_output!(completion)
+    safe_output = Olyx::Guardrails::Rails.redact_output(completion)[:text]
 
-    render json: { completion: completion }, status: :created
+    render json: { completion: safe_output }
   end
 end
 ```
 
-Rails enforcement is opt-in. The gem does not scan parameters, callbacks,
-uploads, jobs, GraphQL operations, or Action Cable messages globally.
-
-The
-[Rails integration guide](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/RAILS.md)
-covers every adapter, boot-time configuration, safe YAML loading,
-instrumentation payloads, and notification delivery.
+`LlmClient` represents your application's existing model client. This controller
+example belongs in a Rails application; it is not a standalone script.
 
-## Choose the right entry point
+Enforcement is opt-in. The gem does not automatically scan every request, job,
+upload, or model call. The [Rails guide](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/RAILS.md) covers controllers,
+Active Job, Active Model, GraphQL, Action Cable, extracted upload text,
+instrumentation, and notifications.
 
-| Boundary | Entry point | Behavior |
-|---|---|---|
-| Plain text input | `Guardrails.check` | Returns an allow/block decision |
-| Structured messages | `Guardrails.check_messages` | Adds adjacent-turn detection |
-| Completed model output | `Guardrails.check_output` | Explicit output decision |
-| Plain text transformation | `Guardrails.redact` | Returns redacted text |
-| Completed output transformation | `Guardrails.redact_output` | Explicit output transformation |
-| Rails exception flow | `Rails::Enforcer.check!` | Raises `Guardrails::Blocked` when rejected |
-| Low-level secret enforcement | `SecretScanner.scan!` | Raises `SecretScanner::Blocked` on a finding |
+## Defaults and operational behavior
 
-All completed-output methods operate on complete values. They do not inspect a
-token stream before content reaches the caller.
-
-## Optional LLM provider
-
-`llm_provider` accepts any callable object. It receives the raw text and a
-bounded context hash containing deterministic findings:
+The default policy:
 
-```ruby
-provider = lambda do |text, context|
-  LocalClassifier.call(text: text, signals: context)
-end
+- rejects input longer than 10,000 Ruby characters;
+- blocks detected prompt injection;
+- reports PII and secrets without blocking them;
+- defines no custom restricted-content rules; and
+- preserves the deterministic decision if an optional LLM provider fails.
 
-policy = Olyx::Guardrails::Policy.new(llm_failure_mode: :block)
+Define an explicit production policy. If semantic analysis is required, choose
+`llm_failure_mode: :block` or `:raise`. The application supplies the classifier
+callable and owns its authentication, transport, timeouts, and retries.
+Semantic findings can add violations but cannot clear deterministic findings.
+See [policies](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/POLICIES.md) and the
+[provider contract](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/API.md#llm-provider-contract).
 
-result = Olyx::Guardrails.check(
-  input,
-  policy: policy,
-  llm_provider: provider
-)
-```
+Rails can publish content-free Active Support events. Optional notifier handlers
+receive sanitized events and run synchronously unless your application queues
+delivery. See [operations](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/OPERATIONS.md) for data handling and failure modes.
 
-The provider returns a hash or schema object containing any of:
+## Limitations
 
-```ruby
-{
-  injection_attempt: false,
-  pii_detected: false,
-  secret_leaked: false,
-  risk_score: 0.2,
-  reason: "No semantic violation found"
-}
-```
+Pattern-based checks can miss novel attacks, paraphrasing, translations,
+unsupported formats, and nested encodings. PII coverage is strongest for the
+documented North American and common international formats. Secret detection
+is format-based. Restricted-content rules do not infer semantic equivalents
+unless your application supplies additional analysis.
 
-The gem owns normalization, validation, failure handling, and safe result
-merging. The application owns model selection, prompting, authentication,
-timeouts, retries, and transport. LLM analysis findings can add a violation but cannot clear a deterministic finding.
+Completed-output methods evaluate complete values; they do not enforce a policy
+on tokens already streamed to a caller. Model routing, tool permissions,
+authorization, file extraction, distributed quotas, and audit storage remain
+application responsibilities.
 
-See the
-[provider contract](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/API.md#llm-provider-contract)
-and
-[local HTTP example](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/local_llm_provider.rb).
-The example works with an application-owned classifier sidecar backed by any
-inference runtime. Read the
-[model-suitability criteria](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/OPERATIONS.md#model-suitability)
-before using semantic analysis as a blocking production control.
+Treat guardrails as one layer of application protection. Read the
+[detection limits](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/OPERATIONS.md#detection-limits) before enabling production
+blocking.
 
-## Documentation
+## Documentation and examples
 
 - [Documentation index](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/README.md)
 - [Policies and restricted content](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/POLICIES.md)
 - [Rails integration](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/RAILS.md)
-- [Operations and production behavior](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/OPERATIONS.md)
-- [API reference](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/API.md)
-- [Release runbook](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/RELEASING.md)
-- [Security policy](https://github.com/Olyx-labs/olyx-guardrails/security/policy)
-- [Contributing](https://github.com/Olyx-labs/olyx-guardrails/blob/master/CONTRIBUTING.md)
-- [Changelog](CHANGELOG.md)
-
-Examples:
-
-- [Framework-free Ruby](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/ruby_only.rb)
-- [Custom policy](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/custom_policy.rb)
-- [Rails opt-in boundaries](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/rails_opt_in.rb)
-- [Local LLM provider](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/local_llm_provider.rb)
+- [Operations and notifications](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/OPERATIONS.md)
+- [Ruby API reference](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/API.md)
+- [Runnable Ruby example](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/ruby_only.rb)
+- [Custom policies](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/custom_policy.rb)
+- [Application-owned local classifier](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/local_llm_provider.rb)
 - [Notifier handlers](https://github.com/Olyx-labs/olyx-guardrails/blob/master/examples/notifier.rb)
 
-The framework-free, custom-policy, and notifier examples run directly. The
-Rails example is application-context code, and the local provider example
-expects the documented classifier sidecar.
-
-## Security model and limitations
-
-Olyx Guardrails is a defense-in-depth control, not a complete semantic security
-boundary or data-loss-prevention system.
-
-- Pattern-based detection can miss paraphrasing, translations, novel attacks,
-  unsupported homoglyphs, and nested encoding beyond the bounded normalization
-  pass.
-- PII support is strongest for documented North American and common
-  international formats.
-- Secret detection is format-based and cannot classify every high-entropy
-  string or future credential format.
-- Restricted-content rules are deterministic unless an application supplies an
-  LLM provider.
-- File parsing, authorization, streaming enforcement, distributed quotas,
-  centralized policy rollout, and audit retention remain application or
-  platform responsibilities.
-
-The
-[operations guide](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/OPERATIONS.md)
-describes failure modes, data handling, risk scores, concurrency, and
-deployment boundaries. Report security issues through the
-[security policy](https://github.com/Olyx-labs/olyx-guardrails/security/policy),
-not the public issue tracker.
-
-## Development
-
-Run the same gates used by CI:
-
-```bash
-bin/setup
-bin/ci
-```
+## Contributing and security
+
+See [CONTRIBUTING.md](https://github.com/Olyx-labs/olyx-guardrails/blob/master/CONTRIBUTING.md) for development setup and checks,
+[CHANGELOG.md](CHANGELOG.md) for release changes, and the
+[release runbook](https://github.com/Olyx-labs/olyx-guardrails/blob/master/docs/RELEASING.md) for maintainer procedures.
+
+Rails adapter changes must also pass `bundle exec appraisal rake test`.
 
-The development bundle includes Rails so contributors exercise the integration
-from the default test suite; Rails remains an optional runtime dependency for
-gem consumers. The Rails compatibility matrix is managed with Appraisal. See
-[contribution guide](https://github.com/Olyx-labs/olyx-guardrails/blob/master/CONTRIBUTING.md)
-before submitting a change.
+Report vulnerabilities through the [security policy](https://github.com/Olyx-labs/olyx-guardrails/blob/master/SECURITY.md).
 
 ## License
 
-Olyx Guardrails is available under the
 [Apache License 2.0](LICENSE).

data/lib/olyx/guardrails/check_result_builder.rb

@@ -10,42 +10,25 @@ module Olyx
 
       module_function
 
+      # Keep the fixed public contract together rather than splitting its fields across helpers.
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def call(checks, analysis, policy)
         ordered = CHECK_ORDER.filter_map { |type| checks[type] }
-        base_result(checks, ordered, policy)
-          .merge(risk(checks, ordered, analysis))
-          .merge(analysis_result(analysis))
-      end
-
-      def base_result(checks, ordered, policy)
-        detection(checks, ordered).merge(policy(checks[:policy], policy))
-      end
-
-      def detection(checks, ordered)
-        {
+        result = {
           allowed: ordered.all? { |check| check[:allowed] },
           pii_detected: checks[:pii][:detected],
           injection_attempt: checks[:injection][:injection_attempt],
-          secret_leaked: checks[:secret][:leaked]
+          secret_leaked: checks[:secret][:leaked],
+          policy_name: policy.name,
+          policy_violated: checks[:policy][:violated],
+          policy_findings: checks[:policy][:findings],
+          risk_score: RiskScorer.call(checks, analysis),
+          checks: ordered
         }
+        result[:llm_analysis] = analysis if analysis
+        result
       end
-
-      def policy(check, configuration)
-        {
-          policy_name: configuration.name,
-          policy_violated: check[:violated],
-          policy_findings: check[:findings]
-        }
-      end
-
-      def risk(checks, ordered, analysis)
-        { risk_score: RiskScorer.call(checks, analysis), checks: ordered }
-      end
-
-      def analysis_result(analysis)
-        analysis ? { llm_analysis: analysis } : {}
-      end
-      private_class_method :base_result, :detection, :policy, :risk, :analysis_result
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     end
   end
 end

data/lib/olyx/guardrails/check_runner.rb

@@ -5,6 +5,7 @@ require_relative 'check_analyzer'
 require_relative 'check_set'
 require_relative 'policy'
 require_relative 'validation'
+require_relative 'message_source'
 
 module Olyx
   module Guardrails
@@ -14,15 +15,18 @@ module Olyx
         new(input, **).call
       end
 
-      def initialize(input, policy:, llm_provider:)
-        @source = input.to_s
+      def initialize(input, policy:, llm_provider:, structured: false)
+        Validation.array_of!(input, Hash, name: 'messages') if structured
+        @messages = input if structured
+        @source = input.to_s unless structured
         @policy = policy
         @llm_provider = llm_provider
         validate_options!
+        @source = MessageSource.call(input) if structured
       end
 
       def call
-        checks = CheckSet.call(@source, policy: @policy)
+        checks = CheckSet.call(@source, policy: @policy, messages: @messages)
         merged, analysis = CheckAnalyzer.call(
           checks, provider: @llm_provider, source: @source, policy: @policy
         )

data/lib/olyx/guardrails/llm_analysis.rb

@@ -1,28 +1,56 @@
 # frozen_string_literal: true
 
-require_relative 'llm/analysis_pipeline'
-
 module Olyx
   module Guardrails
-    # Normalizes and bounds responses from an untrusted optional LLM provider.
-    class LlmAnalysis
+    # Validates the bounded provider contract; raw provider exceptions never escape.
+    module LlmAnalysis
       PROVIDER_ERROR = 'llm_provider failed'
+      INVALID_SHAPE_ERROR = 'llm_provider must return a Hash or a schema model with deep_to_h/to_h'
+      BOOLEAN_KEYS = %i[injection_attempt pii_detected secret_leaked].freeze
+      KEYS = [*BOOLEAN_KEYS, :risk_score, :reason].freeze
 
-      def self.call(provider, text, context)
-        new(provider, text, context).call
-      end
+      module_function
 
-      def initialize(provider, text, context)
-        @provider = provider
-        @text = text
-        @context = context
-      end
+      def call(provider, text, context)
+        result = normalize(provider.call(text, context))
+        return { error: INVALID_SHAPE_ERROR } unless result
 
-      def call
-        Llm::AnalysisPipeline.call(@provider.call(@text, @context))
+        selected = select_fields(result)
+        validation_error(selected) || bound_reason(selected)
       rescue StandardError
         { error: PROVIDER_ERROR }
       end
+
+      def normalize(value)
+        return value if value.is_a?(Hash)
+
+        converted = convert(value)
+        converted if converted.is_a?(Hash)
+      end
+
+      def convert(value)
+        return value.deep_to_h if value.respond_to?(:deep_to_h)
+
+        value.to_h if value.respond_to?(:to_h)
+      end
+
+      def select_fields(result)
+        KEYS.each_with_object({}) do |key, output|
+          source_key = result.key?(key) ? key : key.to_s
+          output[key] = result[source_key] if result.key?(source_key)
+        end
+      end
+
+      def validation_error(result)
+        key = BOOLEAN_KEYS.find { |field| result.key?(field) && ![true, false].include?(result[field]) }
+        { error: "llm_provider #{key} must be true or false" } if key
+      end
+
+      def bound_reason(result)
+        result[:reason] = result[:reason].to_s[0...500] if result.key?(:reason)
+        result
+      end
+      private_class_method :normalize, :convert, :select_fields, :validation_error, :bound_reason
     end
   end
 end

data/lib/olyx/guardrails/message_content.rb

@@ -7,7 +7,7 @@ module Olyx
       module_function
 
       def text(message)
-        content = message['content'] || message[:content]
+        content = value(message, 'content')
         return content if content.is_a?(String)
         return content.filter_map { |block| block_text(block) }.join(' ') if content.is_a?(Array)
 
@@ -15,13 +15,26 @@ module Olyx
       end
 
       def role(message)
-        (message['role'] || message[:role]).to_s.downcase
+        value(message, 'role').to_s.downcase
+      end
+
+      # Redaction preserves a present String key, including explicit nil or false.
+      def key(message, name)
+        return name if message.key?(name)
+
+        symbol = name.to_sym
+        symbol if message.key?(symbol)
+      end
+
+      # Reading preserves the existing truthy String-then-Symbol fallback.
+      def value(message, name)
+        message[name] || message[name.to_sym]
       end
 
       def block_text(block)
-        block['text'] || block[:text] if block.is_a?(Hash)
+        value(block, 'text') if block.is_a?(Hash)
       end
-      private_class_method :block_text
+      private_class_method :block_text, :value
     end
   end
 end

data/lib/olyx/guardrails/pii/block_scrubber.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'hash_key'
+require_relative '../message_content'
 require_relative 'text_scrubber'
 
 module Olyx
@@ -13,7 +13,7 @@ module Olyx
         def call(block)
           return [block, false] unless block.is_a?(Hash)
 
-          key = HashKey.call(block, 'text')
+          key = MessageContent.key(block, 'text')
           text = block[key] if key
           return [block, false] unless text.is_a?(String)
 

data/lib/olyx/guardrails/pii/message_scrubber.rb

@@ -2,7 +2,7 @@
 
 require_relative '../validation'
 require_relative 'content_scrubber'
-require_relative 'hash_key'
+require_relative '../message_content'
 
 module Olyx
   module Guardrails
@@ -18,7 +18,7 @@ module Olyx
         end
 
         def scrub_message(message)
-          key = HashKey.call(message, 'content')
+          key = MessageContent.key(message, 'content')
           return [message, false] unless key
 
           redacted, changed = ContentScrubber.call(message[key])

data/lib/olyx/guardrails/pii/numeric_date_validator.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'ambiguous_numeric_date'
-require_relative 'year_first_date'
+require 'date'
 
 module Olyx
   module Guardrails
     module Pii
-      # Validates year-first or ambiguous day/month numeric dates.
+      # Validates year-first and ambiguous day/month dates without guessing a locale.
       module NumericDateValidator
         PARTS = %r{\A(\d{1,4})[/-](\d{1,2})[/-](\d{1,4})\z}
 
@@ -15,11 +14,17 @@ module Olyx
         def call(value)
           parts = value.match(PARTS)&.captures
           return false unless parts
+          return Date.valid_date?(*parts.map(&:to_i)) if parts.first.length == 4
 
-          return YearFirstDate.call(parts) if parts.first.length == 4
+          ambiguous_date?(parts)
+        end
 
-          AmbiguousNumericDate.call(parts)
+        def ambiguous_date?(parts)
+          first, second, year = parts.map(&:to_i)
+          year += 2_000 if parts.last.length == 2
+          Date.valid_date?(year, second, first) || Date.valid_date?(year, first, second)
         end
+        private_class_method :ambiguous_date?
       end
     end
   end

data/lib/olyx/guardrails/version.rb

@@ -3,6 +3,6 @@
 module Olyx
   module Guardrails
     # The current gem version, following semantic versioning.
-    VERSION = '1.2.0'
+    VERSION = '1.2.1'
   end
 end

data/lib/olyx/guardrails.rb

@@ -9,7 +9,6 @@ require_relative 'guardrails/injection_detector'
 require_relative 'guardrails/secret_scanner'
 require_relative 'guardrails/policy'
 require_relative 'guardrails/check_runner'
-require_relative 'guardrails/message_check_runner'
 require_relative 'guardrails/redactor'
 require_relative 'guardrails/notifier'
 require_relative 'guardrails/rails' if defined?(Rails::Railtie)
@@ -74,7 +73,7 @@ module Olyx
     # +policy+ and +llm_provider+ behave as they do for check. Invalid message
     # structure raises ArgumentError.
     def self.check_messages(messages, policy: Policy.default, llm_provider: nil)
-      MessageCheckRunner.call(messages, policy: policy, llm_provider: llm_provider)
+      CheckRunner.call(messages, policy: policy, llm_provider: llm_provider, structured: true)
     end
 
     # :call-seq:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: olyx-guardrails
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Moses Njoroge
@@ -36,7 +36,7 @@ description: 'Standalone Ruby library for completed AI input and output safety.
   notifications — runs entirely in-process with one lightweight bundled-gem dependency.
   Ships with a provider-agnostic llm_provider: hook for LLM-backed semantic evaluation.'
 email:
-- mosesnjoroge@olyxai.io
+- hello@olyxai.io
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -58,15 +58,10 @@ files:
 - lib/olyx/guardrails/errors.rb
 - lib/olyx/guardrails/injection_detector.rb
 - lib/olyx/guardrails/injection_patterns.rb
-- lib/olyx/guardrails/llm/analysis_normalizer.rb
-- lib/olyx/guardrails/llm/analysis_pipeline.rb
-- lib/olyx/guardrails/llm/boolean_validator.rb
-- lib/olyx/guardrails/llm/result_sanitizer.rb
 - lib/olyx/guardrails/llm_analysis.rb
 - lib/olyx/guardrails/llm_context_builder.rb
 - lib/olyx/guardrails/llm_failure_handler.rb
 - lib/olyx/guardrails/llm_finding_merger.rb
-- lib/olyx/guardrails/message_check_runner.rb
 - lib/olyx/guardrails/message_content.rb
 - lib/olyx/guardrails/message_source.rb
 - lib/olyx/guardrails/multi_turn_injection_detector.rb
@@ -88,11 +83,9 @@ files:
 - lib/olyx/guardrails/notification_sanitizer.rb
 - lib/olyx/guardrails/notifier.rb
 - lib/olyx/guardrails/notifier_configuration.rb
-- lib/olyx/guardrails/pii/ambiguous_numeric_date.rb
 - lib/olyx/guardrails/pii/block_scrubber.rb
 - lib/olyx/guardrails/pii/content_scrubber.rb
 - lib/olyx/guardrails/pii/date_validator.rb
-- lib/olyx/guardrails/pii/hash_key.rb
 - lib/olyx/guardrails/pii/iban_remainder.rb
 - lib/olyx/guardrails/pii/iban_validator.rb
 - lib/olyx/guardrails/pii/ipv4_validator.rb
@@ -106,7 +99,6 @@ files:
 - lib/olyx/guardrails/pii/sin_validator.rb
 - lib/olyx/guardrails/pii/ssn_validator.rb
 - lib/olyx/guardrails/pii/text_scrubber.rb
-- lib/olyx/guardrails/pii/year_first_date.rb
 - lib/olyx/guardrails/pii_scrubber.rb
 - lib/olyx/guardrails/pii_validators.rb
 - lib/olyx/guardrails/policy.rb

data/lib/olyx/guardrails/llm/analysis_normalizer.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Olyx
-  module Guardrails
-    module Llm
-      # Converts supported schema-model results into Hash values.
-      module AnalysisNormalizer
-        module_function
-
-        def call(value)
-          return value if value.is_a?(Hash)
-
-          converted = convert(value)
-          converted if converted.is_a?(Hash)
-        end
-
-        def convert(value)
-          return value.deep_to_h if value.respond_to?(:deep_to_h)
-
-          value.to_h if value.respond_to?(:to_h)
-        end
-        private_class_method :convert
-      end
-    end
-  end
-end

data/lib/olyx/guardrails/llm/analysis_pipeline.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'analysis_normalizer'
-require_relative 'boolean_validator'
-require_relative 'result_sanitizer'
-
-module Olyx
-  module Guardrails
-    module Llm
-      # Applies normalization, selection, Boolean validation, and reason bounds.
-      module AnalysisPipeline
-        INVALID_SHAPE_ERROR = 'llm_provider must return a Hash or a schema model with deep_to_h/to_h'
-
-        module_function
-
-        def call(value)
-          result = AnalysisNormalizer.call(value)
-          return { error: INVALID_SHAPE_ERROR } unless result
-
-          sanitized = ResultSanitizer.call(result)
-          validation_error(sanitized) || bound_reason(sanitized)
-        end
-
-        def validation_error(result)
-          invalid_key = BooleanValidator.invalid_key(result)
-          { error: "llm_provider #{invalid_key} must be true or false" } if invalid_key
-        end
-
-        def bound_reason(result)
-          result[:reason] = result[:reason].to_s[0...500] if result.key?(:reason)
-          result
-        end
-        private_class_method :validation_error, :bound_reason
-      end
-    end
-  end
-end

data/lib/olyx/guardrails/llm/boolean_validator.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Olyx
-  module Guardrails
-    module Llm
-      # Finds the first provider flag whose value is not Boolean.
-      module BooleanValidator
-        KEYS = %i[injection_attempt pii_detected secret_leaked].freeze
-
-        module_function
-
-        def invalid_key(analysis)
-          KEYS.find { |key| analysis.key?(key) && ![true, false].include?(analysis[key]) }
-        end
-      end
-    end
-  end
-end

data/lib/olyx/guardrails/llm/result_sanitizer.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Olyx
-  module Guardrails
-    module Llm
-      # Selects the bounded provider contract from an untrusted result Hash.
-      module ResultSanitizer
-        KEYS = %i[injection_attempt pii_detected secret_leaked risk_score reason].freeze
-
-        module_function
-
-        def call(result)
-          KEYS.each_with_object({}) do |key, output|
-            value, present = value_for(result, key)
-            output[key] = value if present
-          end
-        end
-
-        def value_for(result, key)
-          return [result[key], true] if result.key?(key)
-
-          string_key = key.to_s
-          [result[string_key], result.key?(string_key)]
-        end
-        private_class_method :value_for
-      end
-    end
-  end
-end

data/lib/olyx/guardrails/message_check_runner.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'check_analyzer'
-require_relative 'check_result_builder'
-require_relative 'check_set'
-require_relative 'message_source'
-require_relative 'policy'
-require_relative 'validation'
-
-module Olyx
-  module Guardrails
-    # Orchestrates checks for structured chat messages.
-    class MessageCheckRunner
-      def self.call(messages, policy: Policy.default, llm_provider: nil)
-        Validation.array_of!(messages, Hash, name: 'messages')
-        raise ArgumentError, 'policy must be an Olyx::Guardrails::Policy' unless policy.is_a?(Policy)
-
-        Validation.callable_or_nil!(llm_provider, name: 'llm_provider')
-        source = MessageSource.call(messages)
-        checks = CheckSet.call(source, policy: policy, messages: messages)
-        merged, analysis = CheckAnalyzer.call(checks, provider: llm_provider, source: source, policy: policy)
-        CheckResultBuilder.call(merged, analysis, policy)
-      end
-    end
-  end
-end

data/lib/olyx/guardrails/pii/ambiguous_numeric_date.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'date'
-
-module Olyx
-  module Guardrails
-    module Pii
-      # Accepts valid day-first or month-first numeric dates.
-      module AmbiguousNumericDate
-        module_function
-
-        def call(parts)
-          first, second, raw_year = parts.map(&:to_i)
-          valid?(first, second, year(raw_year, parts.last))
-        end
-
-        def valid?(first, second, year)
-          candidates(first, second).any? { |month, day| Date.valid_date?(year, month, day) }
-        end
-
-        def candidates(first, second)
-          [[second, first], [first, second]]
-        end
-
-        def year(value, source)
-          source.length == 2 ? value + 2_000 : value
-        end
-        private_class_method :candidates, :valid?, :year
-      end
-    end
-  end
-end

data/lib/olyx/guardrails/pii/hash_key.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Olyx
-  module Guardrails
-    module Pii
-      # Finds String or Symbol variants of a Hash key.
-      module HashKey
-        module_function
-
-        def call(hash, name)
-          return name if hash.key?(name)
-
-          symbol = name.to_sym
-          symbol if hash.key?(symbol)
-        end
-      end
-    end
-  end
-end

data/lib/olyx/guardrails/pii/year_first_date.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'date'
-
-module Olyx
-  module Guardrails
-    module Pii
-      # Validates numeric dates whose first component is a four-digit year.
-      module YearFirstDate
-        module_function
-
-        def call(parts)
-          Date.valid_date?(*parts.map(&:to_i))
-        end
-      end
-    end
-  end
-end