data_redactor 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59ae814186478e16f6ba16f66aa1dfa8f3fd63d088cd5c837221d7530c6a0c73
-  data.tar.gz: 631c2a6f5198d7c2e741f9a283263ffbadfb49053bf6767ba57cce67b33e381f
+  metadata.gz: bde76b717309c4a58b5fbe2cd85c7986622291a9e8f6a7c1e7423ae804ef0246
+  data.tar.gz: 497e5edb87745db889ab2900ef9a275335357311b747327d036d91a687008b94
 SHA512:
-  metadata.gz: a5fdcc1bf088c9065f7e0c458fa4cf210917d688cb9b2b17e0824e59e9757f2f9c0491ef53c0e91f7ff29ac971b1ef6cc2d434a1d80505206e2d9f5b36893ca9
-  data.tar.gz: 1457805dc7599d1655ebb8bc569607be3380290f99f65cdf15cdc17fc7431932e4ff4250f967ff0d7459350d1d836c4d63857bf0b90ad408c2fcd7a969ab453f
+  metadata.gz: 4bc80d118f450b5798d8c7932fe39e1513c897842e40bf370f0d8b66d37ab180a3c4aae52ee1c85628a81a57c5612d67b969cd060b0023ab5d549be14c128bf7
+  data.tar.gz: af61f49db51ddc2d0806cb392700c93c4fde3a869e9e089f615ae26acabb6b777e38792d0fb061c53e5a01bc69355d8b95a9c5f60946e3a393df3f2ef958f066

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/ext/data_redactor/matcher.c

@@ -1,6 +1,6 @@
 /* matcher.c — the v19 multi-pattern engine, ported into the gem.
  *
- * Ported from prototypes/multi_matcher_v1/matcher19.c (the standalone prototype
+ * Ported from prototypes/multi_pattern_matcher/matcher19.c (the standalone prototype
  * proven in docs/research_log.md). The matching core — regex parser -> Thompson
  * bytecode -> per-pattern lazy DFA, the v14 first-byte filter, the v12 literal
  * skip, the v18.1 anchor lowering, the v19 pure-digit and IBAN selective merges,
@@ -22,7 +22,7 @@
  *      TODO.md §1d Gap 5 and the AKIA specs in spec/data_redactor_spec.rb.
  *
  * The infix-literal classification and the BM_INFIX hint table below are ported
- * from prototypes/multi_matcher_v1/gen_patterns.rb (which derived them from the
+ * from prototypes/multi_pattern_matcher/gen_patterns.rb (which derived them from the
  * same gem arrays at codegen time). They are pure optimisation hints — the
  * first-byte filter computed from the program itself is what guarantees
  * correctness — so a stale hint can only cost speed, never miss a match.

data/ext/data_redactor/matcher.h

@@ -8,7 +8,7 @@
  * interned DFA) with two selective merges (pure-digit run pass, IBAN union
  * pass) and the v19.1 EOL-at-buffer-end fix. Zero dependencies beyond libc.
  * See docs/research_log.md (v15..v19) for the derivation, and
- * prototypes/multi_matcher_v1/ for the standalone prototype this is ported from.
+ * prototypes/multi_pattern_matcher/ for the standalone prototype this is ported from.
  *
  * Built-in pattern engines are sourced from the gem's pattern arrays
  * (pattern_strings[]/boundary_wrapped[]/pattern_required_literal[]), NOT a

data/ext/data_redactor/patterns.c

@@ -458,8 +458,12 @@ const char *pattern_strings[NUM_PATTERNS] = {
     "-----BEGIN PGP PRIVATE KEY BLOCK-----",
     /* 29: HashiCorp Vault Service Token (hvs. + 90-120 base64url chars) */
     "hvs\\.[A-Za-z0-9_-]{90,120}",
-    /* 30: HashiCorp Vault Batch Token (hvb. + 138-300 base64url chars) */
-    "hvb\\.[A-Za-z0-9_-]{138,300}",
+    /* 30: HashiCorp Vault Batch Token (hvb. + 138+ base64url chars).
+     * Upper bound capped at POSIX RE_DUP_MAX (255), not gitleaks' 300: musl's
+     * regcomp rejects {m,n} with n>255 ("Invalid contents of {}"), so the gem
+     * failed to load on Alpine. 255 still neutralizes the token (prefix + 251+
+     * chars redacted); only an unusually long >255-char token leaves a dead tail. */
+    "hvb\\.[A-Za-z0-9_-]{138,255}",
     /* 31: HashiCorp Terraform Cloud API Token (14 alphanum + .atlasv1. + 60-70 base64url chars) */
     "[A-Za-z0-9]{14}\\.atlasv1\\.[A-Za-z0-9_=-]{60,70}",
 

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: ruby
 authors:
 - Daniele Frisanco
@@ -121,6 +121,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
+- README.md
 - ext/data_redactor/custom_patterns.c
 - ext/data_redactor/custom_patterns.h
 - ext/data_redactor/data_redactor.c
@@ -137,12 +138,14 @@ files:
 - ext/data_redactor/scan.h
 - ext/data_redactor/tags.h
 - lib/data_redactor.rb
+- 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