data_redactor 0.10.0-x86_64-linux → 0.11.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c68f704fce41662e1b7829085e9fadffa4931dae4323f528916897164cfdf5b
-  data.tar.gz: 1d91d3f55059e579cf36967eb06294ed18e7a54c3c1396971a749d30570118e4
+  metadata.gz: 79d2dc2a7a24145626e06741bdec238660b21d2cc2268e824878238e62d8331b
+  data.tar.gz: 8e15d8faddbf76cf4d339efe14b88d401e91b4f67ed911682a7dad75b29ca384
 SHA512:
-  metadata.gz: c5df30474632d5026ca2a79e8be61fc020a4cb72cd7c3fb9333134d03a7d8430380185a0d209eabab33b2f27b6502ca7e9e34fb5c8fdd6df9ac24b2d71e33bd5
-  data.tar.gz: b0fd12a2666dfa50e9dd18ecb3a6733ca712ea5f1a8ea31305bd0cf788fa766cba9720c3891deec67c3eace73dafca2cc5fc566712d8bdb627b2bc9eac818b81
+  metadata.gz: 37103c8e31cc7271ba2bc0903ceb90fc09d3e2f39441264249e3adb16ff40ed3ffcc713f31f78134fd2f7df3f1a635bfc01e625d52c0a978b405793ec3d18082
+  data.tar.gz: 4aa60db835020332e65f1a24d93b584143a203695469a9a94b9c3974f12803146d8778dde4e62ce0d020f740417255c3385da120ccec64aa489cce7be21c5c34

data/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-06-10
+
+### Added
+- **Claude / OpenAI LLM integrations** — two new soft-required adapters that
+  scrub PII and secrets from LLM payloads before they leave the process and
+  from responses before they're logged:
+  - `DataRedactor::Integrations::Claude` — `.redact_messages` (handles the
+    `messages` array plus a top-level `system:` prompt; String or
+    array-of-content-block content) and `.redact_response` (Messages API
+    `content` text blocks).
+  - `DataRedactor::Integrations::OpenAI` — `.redact_messages` (Chat
+    Completions `messages`, including a `system` message and array-of-parts
+    content) and `.redact_response` (`choices[].message.content`).
+  Both operate on plain Ruby Hashes/Arrays with String or Symbol keys (no
+  runtime dependency on the `anthropic`/`openai` gems), return a deep copy
+  (never mutate the caller's input), pass non-text content blocks through
+  untouched, and forward `only:`/`except:`/`placeholder:` to
+  `DataRedactor.redact`.
+
+## [0.10.1] - 2026-06-10
+
+### Fixed
+- **musl/Alpine load failure** — the `hashicorp_vault_batch_token` pattern used a
+  `{138,300}` interval whose upper bound exceeds POSIX `RE_DUP_MAX` (255). glibc
+  accepts it, but musl's `regcomp` rejects it ("Invalid contents of {}"), so the
+  native musl gem raised at load (`require "data_redactor"`) on Alpine. Capped the
+  bound at 255; tokens are still neutralized (prefix + 251+ chars redacted).
+
 ## [0.10.0] - 2026-06-09
 
 ### Changed
@@ -204,7 +232,10 @@ features as 0.7.1 plus the pipeline fix.
 - `DataRedactor.redact(text)` module function returning the input with every match replaced by `[REDACTED]`.
 - RSpec suite with one example per pattern.
 
-[Unreleased]: https://github.com/danielefrisanco/data_redactor/compare/v0.9.0...HEAD
+[Unreleased]: https://github.com/danielefrisanco/data_redactor/compare/v0.11.0...HEAD
+[0.11.0]: https://github.com/danielefrisanco/data_redactor/compare/v0.10.1...v0.11.0
+[0.10.1]: https://github.com/danielefrisanco/data_redactor/compare/v0.10.0...v0.10.1
+[0.10.0]: https://github.com/danielefrisanco/data_redactor/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/danielefrisanco/data_redactor/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/danielefrisanco/data_redactor/compare/v0.7.2...v0.8.0
 [0.7.2]: https://github.com/danielefrisanco/data_redactor/compare/v0.7.1...v0.7.2

data/{readme.md → README.md}

@@ -275,6 +275,34 @@ Pass an empty subset (e.g. `scrub: [:headers]`) to opt out of body wrapping. For
 
 > **Body wrapping is buffering.** The middleware reads the entire response body into memory before scanning. For streaming endpoints (SSE, large file downloads, Rack::Hijack) use `scrub: [:headers]` and rely on the Logger formatter for application logs instead.
 
+### Claude / OpenAI LLM payloads
+
+Sanitize LLM message payloads before they leave the process, and scrub responses before they're logged or stored. Both adapters operate on plain Ruby Hashes/Arrays (String **or** Symbol keys), so they work with the `anthropic`/`openai` gems, a raw HTTP client, or parsed JSON — no runtime dependency on any SDK. They **return a deep copy and never mutate your input**, and forward `only:`/`except:`/`placeholder:` to `DataRedactor.redact`.
+
+```ruby
+require "data_redactor/integrations/claude"
+
+# Redact a messages array before sending to Claude
+safe_messages = DataRedactor::Integrations::Claude.redact_messages(messages)
+client.messages.create(model: "claude-opus-4-8", max_tokens: 1024, messages: safe_messages)
+
+# Redact the response (assistant content blocks) before logging
+safe_response = DataRedactor::Integrations::Claude.redact_response(response)
+```
+
+```ruby
+require "data_redactor/integrations/openai"
+
+# Redact a messages array before sending to OpenAI
+safe_messages = DataRedactor::Integrations::OpenAI.redact_messages(messages)
+client.chat(parameters: { model: "gpt-4o", messages: safe_messages })
+
+# Redact the response (choices[].message.content) before logging
+safe_response = DataRedactor::Integrations::OpenAI.redact_response(response)
+```
+
+`content` may be a plain String or an array of content blocks/parts (`{ type: "text", text: "..." }`) — only the `text` of `text` blocks is redacted; image and other block types pass through untouched. For Claude, a top-level `system:` String is also redacted; for OpenAI, a `{ role: "system" }` message in the array is redacted like any other. Pass a bare `messages` array or the whole request Hash (with a `messages` key) — either works.
+
 ## Detected patterns (88 total)
 
 The table below is a representative sample. Use `DataRedactor.pattern_names` for the canonical, machine-readable list — it stays in sync with the C extension automatically.
@@ -510,6 +538,26 @@ All payload sizes pass a correctness check (redaction count matches pure-Ruby `g
 The previous engine (per-pattern `regexec`) was **4.25× slower** than pure Ruby on the
 1 MB payload — a ~9× swing. Old numbers are in git history (`CHANGELOG.md` [0.9.0]).
 
+#### Linear scaling
+
+Throughput stays flat as input grows — the single-pass engine is O(N), so a 10×
+larger payload takes ~10× longer and MB/s holds steady. The old per-pattern
+`regexec` engine was O(N²) and fell off a cliff on large inputs (a 10 MB log took
+tens of seconds); v19 redacts the same 10 MB in ~1.4 s.
+
+| Size   | Time     | MB/s    |
+|--------|----------|---------|
+| 1 KB   | 0.14 ms  | 7.1     |
+| 100 KB | 13.4 ms  | 7.3     |
+| 1 MB   | 142 ms   | 7.0     |
+| 10 MB  | 1.42 s   | 7.0     |
+| 50 MB  | 7.14 s   | 7.0     |
+
+No published benchmarks exist for comparable Ruby PII-redaction gems, so the
+numbers above are absolute (vs pure-Ruby `gsub`), not a head-to-head against
+another gem. Run `benchmark/scaling.rb` on your own hardware — absolute MB/s is
+machine-dependent, but the flat curve is not.
+
 ## How it works
 
 1. At load time, `Init_data_redactor` compiles all 85 regex patterns once using `regcomp` (POSIX ERE) and stores them as static `regex_t` structs. Patterns marked as boundary-wrapped are expanded with `wrap_boundary()` before compilation.
@@ -523,7 +571,7 @@ All C-side buffers are heap-allocated with `malloc`/`strdup` and freed before th
 
 ## Thread safety
 
-`DataRedactor.redact` and `DataRedactor.scan` are safe to call concurrently from multiple threads. Built-in patterns are compiled into a static `regex_t` array at load time and never mutated afterward, and each call allocates its own working buffers. POSIX `regexec` is documented as thread-safe.
+`DataRedactor.redact` and `DataRedactor.scan` are safe to call concurrently from multiple threads. The v19 engine holds MRI's GVL for the duration of each call (no `rb_thread_call_without_gvl`), so concurrent calls are serialised by the GVL. Each call allocates its own working buffers; built-in engine state is read-only after `mm_init()` at load time.
 
 `DataRedactor.add_pattern`, `remove_pattern`, and `clear_custom_patterns!` mutate a shared dynamic array and are **not** thread-safe. Register custom patterns once at boot — before spawning worker threads or forking — and they will be visible (read-only) to every subsequent `redact`/`scan` call.
 
@@ -540,4 +588,4 @@ Released under the [MIT License](LICENSE).
 - **Pattern ordering matters** — patterns run sequentially. An early broad pattern (e.g. the 9-digit passport) may consume digits that a later pattern (e.g. credit card) depends on. Boundary wrapping mitigates this for pure-digit patterns.
 - **AWS Secret Key (pattern 1)** — 40 consecutive base64 characters is a broad match. It can produce false positives in base64-encoded content such as embedded images or binary blobs.
 - **Duplicate digit patterns** — several national ID formats share the same digit-length (11 digits: PESEL, Norwegian Fødselsnummer, Belgian National Number). They are kept as separate slots for clarity but the practical effect is that any 11-digit boundary-delimited number will be redacted.
-- **Performance is currently slower than pure-Ruby `gsub`.** A May 2026 investigation found the C extension is 3–5× slower than a pure-Ruby `gsub` loop running the same 88 patterns, across input sizes from 168 bytes to 1 MB. The root cause is glibc's POSIX `regexec()`: each call allocates an O(input-length) state buffer before any matching begins, and the gem calls it once per pattern in sequence. Ruby's Onigmo engine wins by using a built-in Boyer-Moore literal pre-filter that this gem can only approximate. Two perf fixes have shipped (buffer-sizing in `replace_all_matches`, a `strstr` literal pre-filter, and input chunking for large payloads), which gave ~25-30% improvement and made scaling linear, but the absolute gap remains. Use the gem on small payloads where the absolute latency is still acceptable (< 1 ms for typical log lines); for high-throughput pipelines, hold off until the next major release. See `docs/standalone_matcher_design.md` for the long-term plan.
+- **Single-pass overlap semantics** — built-in patterns are resolved by an index-order greedy claim: the lower-index pattern wins any region it matches. When two secrets abut with no separator, a rewrite-created word boundary can cause the second to be missed. This is rare in real text (secrets are almost always separator-delimited) and will be fixed by the upcoming longest-match-wins resolver in 1.0.

data/lib/data_redactor/integrations/claude.rb

@@ -0,0 +1,113 @@
+require "data_redactor"
+require "data_redactor/integrations/llm_support"
+
+module DataRedactor
+  module Integrations
+    # Adapter for Anthropic Claude (Messages API) payloads. Scrubs PII and
+    # secrets from a request's `messages` (and top-level `system:` prompt)
+    # before they leave the process, and from a response's `content` blocks
+    # before they're logged or stored.
+    #
+    # Operates on plain Ruby Hashes/Arrays with either String or Symbol keys,
+    # so it works with the `anthropic` gem, a raw HTTP client, or parsed JSON —
+    # no runtime dependency on any SDK. Inputs are never mutated; a deep copy
+    # is returned.
+    #
+    # @example Scrub a request before sending
+    #   require "data_redactor/integrations/claude"
+    #
+    #   messages = [{ role: "user", content: "my email is alice@example.com" }]
+    #   safe = DataRedactor::Integrations::Claude.redact_messages(messages)
+    #   client.messages.create(model: "claude-opus-4-8", max_tokens: 1024,
+    #                          messages: safe)
+    #
+    # @example Scrub a response before logging
+    #   resp = client.messages.create(...)
+    #   logger.info DataRedactor::Integrations::Claude.redact_response(resp)
+    module Claude
+      module_function
+
+      # Redact a Claude `messages` array (and an optional top-level `system:`
+      # String) before sending the request. Returns a deep copy; the input is
+      # not mutated.
+      #
+      # Each message's `content` may be a String or an array of content blocks
+      # (`{ type: "text", text: "..." }`); only the `text` field of `text`
+      # blocks is redacted. Non-text blocks (e.g. `image`) pass through
+      # untouched.
+      #
+      # @param messages [Array<Hash>, Hash] either a bare array of
+      #   `{ role:, content: }` hashes, or a request Hash containing a
+      #   `messages` key and an optional `system` key. Keys may be String or
+      #   Symbol.
+      # @param only forwarded to {DataRedactor.redact}
+      # @param except forwarded to {DataRedactor.redact}
+      # @param placeholder forwarded to {DataRedactor.redact}
+      # @return [Array<Hash>, Hash] a deep copy of the input with text leaves
+      #   redacted; an Array if an Array was given, a Hash if a Hash was given.
+      # @example
+      #   Claude.redact_messages([{ role: "user", content: "ssn 123-45-6789" }])
+      #   #=> [{ role: "user", content: "ssn [REDACTED]" }]
+      def redact_messages(messages, only: nil, except: nil, placeholder: DataRedactor::PLACEHOLDER_DEFAULT)
+        redact = ->(s) { DataRedactor.redact(s, only: only, except: except, placeholder: placeholder) }
+
+        if messages.is_a?(Hash)
+          out = LLMSupport.deep_copy(messages)
+          sys = LLMSupport.fetch(out, :system)
+          LLMSupport.put(out, :system, redact.call(sys)) if sys.is_a?(String)
+          list = LLMSupport.fetch(out, :messages)
+          LLMSupport.put(out, :messages, redact_message_list(list, redact)) if list.is_a?(Array)
+          out
+        else
+          redact_message_list(LLMSupport.deep_copy(messages), redact)
+        end
+      end
+
+      # Redact a Claude Messages API response before logging or storing it.
+      # Returns a deep copy; the input is not mutated.
+      #
+      # Walks the response's `content` array and redacts the `text` field of
+      # each `text` block, leaving the rest of the response (id, role, usage,
+      # non-text blocks) intact.
+      #
+      # @param response [Hash] a Claude response Hash with a `content` array of
+      #   blocks. Keys may be String or Symbol.
+      # @param only forwarded to {DataRedactor.redact}
+      # @param except forwarded to {DataRedactor.redact}
+      # @param placeholder forwarded to {DataRedactor.redact}
+      # @return [Hash] a deep copy of the response with text blocks redacted.
+      # @example
+      #   Claude.redact_response(
+      #     "content" => [{ "type" => "text", "text" => "card 4111111111111111" }]
+      #   )
+      #   #=> {"content"=>[{"type"=>"text", "text"=>"card [REDACTED]"}]}
+      def redact_response(response, only: nil, except: nil, placeholder: DataRedactor::PLACEHOLDER_DEFAULT)
+        redact = ->(s) { DataRedactor.redact(s, only: only, except: except, placeholder: placeholder) }
+        out = LLMSupport.deep_copy(response)
+        return out unless out.is_a?(Hash)
+
+        content = LLMSupport.fetch(out, :content)
+        LLMSupport.put(out, :content, LLMSupport.redact_text_blocks(content, redact)) if content.is_a?(Array)
+        out
+      end
+
+      # @!visibility private
+      # Redact each message's content (String or array of blocks) in place.
+      # Expects an already-deep-copied list.
+      def redact_message_list(messages, redact)
+        messages.map do |msg|
+          next msg unless msg.is_a?(Hash)
+
+          content = LLMSupport.fetch(msg, :content)
+          case content
+          when String
+            LLMSupport.put(msg, :content, redact.call(content))
+          when Array
+            LLMSupport.put(msg, :content, LLMSupport.redact_text_blocks(content, redact))
+          end
+          msg
+        end
+      end
+    end
+  end
+end

data/lib/data_redactor/integrations/llm_support.rb

@@ -0,0 +1,63 @@
+require "data_redactor"
+
+module DataRedactor
+  module Integrations
+    # Shared helpers for the LLM payload adapters ({Claude}, {OpenAI}).
+    #
+    # Both adapters operate on plain Ruby Hashes/Arrays whose keys may be
+    # String or Symbol, never mutate the caller's input, and redact only the
+    # `text` field of text content blocks. This module holds that common,
+    # non-trivial logic; the per-provider modules keep only their own
+    # provider-specific shape walking.
+    #
+    # @!visibility private
+    module LLMSupport
+      module_function
+
+      # Read a key from a Hash that may use String or Symbol keys.
+      # @return the value under the Symbol or String form of `key`, or nil.
+      def fetch(hash, key)
+        hash.key?(key) ? hash[key] : hash[key.to_s]
+      end
+
+      # Write a value back under whichever key form (String/Symbol) the Hash
+      # already uses for `key`, defaulting to the Symbol form.
+      # @return [void]
+      def put(hash, key, value)
+        if hash.key?(key.to_s)
+          hash[key.to_s] = value
+        else
+          hash[key] = value
+        end
+      end
+
+      # Recursively copy a Hash/Array/String structure so the original is never
+      # mutated. Non-container, non-String leaves are returned as-is.
+      # @return a deep copy of `obj`.
+      def deep_copy(obj)
+        case obj
+        when Hash   then obj.each_with_object({}) { |(k, v), o| o[k] = deep_copy(v) }
+        when Array  then obj.map { |v| deep_copy(v) }
+        when String then obj.dup
+        else obj
+        end
+      end
+
+      # Redact the `text` field of each `text` content block in `blocks`,
+      # passing non-text blocks (e.g. images) through untouched. Mutates the
+      # blocks in `blocks` (call on an already-copied structure).
+      # @param blocks [Array] content blocks.
+      # @param redact [#call] a String -> String redaction lambda.
+      # @return [Array] the same `blocks` array, with text blocks redacted.
+      def redact_text_blocks(blocks, redact)
+        blocks.map do |block|
+          next block unless block.is_a?(Hash)
+
+          text = fetch(block, :text)
+          put(block, :text, redact.call(text)) if text.is_a?(String)
+          block
+        end
+      end
+    end
+  end
+end

data/lib/data_redactor/integrations/openai.rb

@@ -0,0 +1,118 @@
+require "data_redactor"
+require "data_redactor/integrations/llm_support"
+
+module DataRedactor
+  module Integrations
+    # Adapter for OpenAI Chat Completions payloads. Scrubs PII and secrets from
+    # a request's `messages` before they leave the process, and from a
+    # response's `choices[].message.content` before they're logged or stored.
+    #
+    # Operates on plain Ruby Hashes/Arrays with either String or Symbol keys,
+    # so it works with the `openai` gem, a raw HTTP client, or parsed JSON — no
+    # runtime dependency on any SDK. Inputs are never mutated; a deep copy is
+    # returned.
+    #
+    # @example Scrub a request before sending
+    #   require "data_redactor/integrations/openai"
+    #
+    #   messages = [{ role: "user", content: "my email is alice@example.com" }]
+    #   safe = DataRedactor::Integrations::OpenAI.redact_messages(messages)
+    #   client.chat(parameters: { model: "gpt-4o", messages: safe })
+    #
+    # @example Scrub a response before logging
+    #   resp = client.chat(parameters: { ... })
+    #   logger.info DataRedactor::Integrations::OpenAI.redact_response(resp)
+    module OpenAI
+      module_function
+
+      # Redact an OpenAI `messages` array before sending the request. Returns a
+      # deep copy; the input is not mutated.
+      #
+      # Each message's `content` may be a String or an array of parts
+      # (`{ type: "text", text: "..." }`); only the `text` field of `text`
+      # parts is redacted. Non-text parts (e.g. `image_url`) pass through
+      # untouched. A `{ role: "system", content: ... }` entry is redacted like
+      # any other message (OpenAI carries the system prompt in the array).
+      #
+      # @param messages [Array<Hash>, Hash] either a bare array of
+      #   `{ role:, content: }` hashes, or a request Hash containing a
+      #   `messages` key. Keys may be String or Symbol.
+      # @param only forwarded to {DataRedactor.redact}
+      # @param except forwarded to {DataRedactor.redact}
+      # @param placeholder forwarded to {DataRedactor.redact}
+      # @return [Array<Hash>, Hash] a deep copy of the input with text leaves
+      #   redacted; an Array if an Array was given, a Hash if a Hash was given.
+      # @example
+      #   OpenAI.redact_messages([{ role: "user", content: "ssn 123-45-6789" }])
+      #   #=> [{ role: "user", content: "ssn [REDACTED]" }]
+      def redact_messages(messages, only: nil, except: nil, placeholder: DataRedactor::PLACEHOLDER_DEFAULT)
+        redact = ->(s) { DataRedactor.redact(s, only: only, except: except, placeholder: placeholder) }
+
+        if messages.is_a?(Hash)
+          out = LLMSupport.deep_copy(messages)
+          list = LLMSupport.fetch(out, :messages)
+          LLMSupport.put(out, :messages, redact_message_list(list, redact)) if list.is_a?(Array)
+          out
+        else
+          redact_message_list(LLMSupport.deep_copy(messages), redact)
+        end
+      end
+
+      # Redact an OpenAI Chat Completions response before logging or storing it.
+      # Returns a deep copy; the input is not mutated.
+      #
+      # Walks `choices[].message.content` and redacts each (String content),
+      # leaving the rest of the response (id, usage, finish_reason) intact.
+      #
+      # @param response [Hash] a response Hash with a `choices` array, each
+      #   choice carrying a `message` Hash with a `content` String. Keys may be
+      #   String or Symbol.
+      # @param only forwarded to {DataRedactor.redact}
+      # @param except forwarded to {DataRedactor.redact}
+      # @param placeholder forwarded to {DataRedactor.redact}
+      # @return [Hash] a deep copy of the response with message content redacted.
+      # @example
+      #   OpenAI.redact_response(
+      #     "choices" => [{ "message" => { "content" => "card 4111111111111111" } }]
+      #   )
+      #   #=> {"choices"=>[{"message"=>{"content"=>"card [REDACTED]"}}]}
+      def redact_response(response, only: nil, except: nil, placeholder: DataRedactor::PLACEHOLDER_DEFAULT)
+        redact = ->(s) { DataRedactor.redact(s, only: only, except: except, placeholder: placeholder) }
+        out = LLMSupport.deep_copy(response)
+        return out unless out.is_a?(Hash)
+
+        choices = LLMSupport.fetch(out, :choices)
+        return out unless choices.is_a?(Array)
+
+        choices.each do |choice|
+          next unless choice.is_a?(Hash)
+
+          message = LLMSupport.fetch(choice, :message)
+          next unless message.is_a?(Hash)
+
+          content = LLMSupport.fetch(message, :content)
+          LLMSupport.put(message, :content, redact.call(content)) if content.is_a?(String)
+        end
+        out
+      end
+
+      # @!visibility private
+      # Redact each message's content (String or array of parts) in place.
+      # Expects an already-deep-copied list.
+      def redact_message_list(messages, redact)
+        messages.map do |msg|
+          next msg unless msg.is_a?(Hash)
+
+          content = LLMSupport.fetch(msg, :content)
+          case content
+          when String
+            LLMSupport.put(msg, :content, redact.call(content))
+          when Array
+            LLMSupport.put(msg, :content, LLMSupport.redact_text_blocks(content, redact))
+          end
+          msg
+        end
+      end
+    end
+  end
+end

data/lib/data_redactor/integrations/rack.rb

@@ -2,7 +2,8 @@ require "data_redactor"
 
 module DataRedactor
   # Namespace for the optional framework adapters under
-  # +lib/data_redactor/integrations/+ ({Logger}, +Rails+, {Rack}).
+  # +lib/data_redactor/integrations/+ ({Logger}, +Rails+, {Rack},
+    # {Claude}, {OpenAI}).
   #
   # Each adapter is soft-required — none load with +require "data_redactor"+;
   # +require+ only the one you need. They add no runtime gem dependencies and

data/lib/data_redactor/version.rb

@@ -1,4 +1,4 @@
 module DataRedactor
   # Current gem version. Follows {https://semver.org Semantic Versioning 2.0.0}.
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: data_redactor
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: x86_64-linux
 authors:
 - Daniele Frisanco
@@ -106,6 +106,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
+- README.md
 - lib/data_redactor.rb
 - lib/data_redactor/3.0/data_redactor.so
 - lib/data_redactor/3.1/data_redactor.so
@@ -113,12 +114,14 @@ files:
 - lib/data_redactor/3.3/data_redactor.so
 - lib/data_redactor/3.4/data_redactor.so
 - lib/data_redactor/4.0/data_redactor.so
+- lib/data_redactor/integrations/claude.rb
+- lib/data_redactor/integrations/llm_support.rb
 - lib/data_redactor/integrations/logger.rb
+- lib/data_redactor/integrations/openai.rb
 - lib/data_redactor/integrations/rack.rb
 - lib/data_redactor/integrations/rails.rb
 - lib/data_redactor/name_pattern.rb
 - lib/data_redactor/version.rb
-- readme.md
 homepage: https://github.com/danielefrisanco/data_redactor
 licenses:
 - MIT