ruby_llm-infinite_context 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3b5d8dd372848f3ae7d47169dc6b2aae612c7ea8642ce02e77dbe3e885f82e7
-  data.tar.gz: 77b06484bf8102c34a1180429dbe6edbf80fa2e9d43bc2567d406a1f9b1015da
+  metadata.gz: dc3d9691bbb8cb8946147e01ba994af1fea69a31385dbd4647b604b27647d78c
+  data.tar.gz: 34ffa318976bfd865455586fff35c9134129e6ac3306ae1a5e25be226c367872
 SHA512:
-  metadata.gz: afc5f0a653883822ba4b47c57eec3e96e2db5ce7c3ac8bd7d95baf542341b7d555177ad1442f4b3ae69fd3bd877549850dce6d371aa1e406b3926b1ff086832c
-  data.tar.gz: 4b5ae78486a80e821b2dbb43968155f338623b4af356621caacd28a81ebb6ffa3cdd5c48f63a53da7cd0ba3fdf185616ece50bbf2c25f7b0cd54a80be66fba44
+  metadata.gz: 1b5fbd9b3cd479c683fb394369b66f2b55922485a52f720e2d3cc3c037f330b40626cd5aa00b065c59116ec115be821df4f13420cd6db8086b01f9f16f259263
+  data.tar.gz: '08a3a7c55addf87a36384b69639a800d7b9b7a480264e8c8d91977e03989fe9cea5a489b54fd1ebc12a014996e408c742d39485c263953adca514a7ba8bb1f8d'

data/CHANGELOG.md

@@ -4,7 +4,32 @@ All notable changes to this gem. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the gem follows
 [Semantic Versioning](https://semver.org/).
 
-## [0.1.0] - not yet released
+## [0.2.0] - not yet released
+
+### Added
+
+- `RubyLLM::InfiniteContext.encrypt_text = true`: Active Record Encryption (non-deterministic)
+  on `ric_entries.text` and `ric_nodes.text`. It works if the models load before or after the
+  setting, declares `encrypts` once, and cannot be turned off again in the same process. The
+  gem never searches these columns in SQL, so every feature works with it on. The README shows
+  the setup, the rules, and how to declare it yourself with `to_prepare`.
+- `RubyLLM::InfiniteContext.required_protocol = :chat_completions`: every chat the gem builds
+  or uses (the compactor, the pump and `PumpJob`, each turn of `attach` and the
+  `Model` concern, and chats passed in by the caller) must use that protocol. Any other
+  protocol, none, a chat whose protocol cannot be read, or a fallback to another provider
+  raises `RubyLLM::InfiniteContext::ProtocolError` before a request is sent. `BatchImport`
+  (`submit` and `collect!`) always raises `ProtocolError` under this rule, before it logs or
+  submits anything: provider batch jobs are not chat completions calls. Load old threads with
+  `tree.append` and `Pump::Runner` instead.
+- `rake test:encrypted` runs the library tests again with encryption on; `rake` runs both.
+
+### Changed
+
+- `Manager#turn` builds the chat before it logs the user's message, so a chat that fails to
+  build leaves no half turn in the log.
+- The pump stops and raises on a `ProtocolError` instead of logging it and retrying.
+
+## [0.1.0] - 2026-11-09
 
 First version. The gem is not on rubygems.org yet.
 

data/README.md

@@ -9,7 +9,9 @@ agent gets tools to zoom into any line, down to the original message.
 
 ## Status
 
-0.1.0 is the first version and has not been released yet. It has been tested end to end on three
+0.2.0 adds Active Record Encryption for the text columns and a way to require one wire
+protocol for every chat the gem uses (see below and `CHANGELOG.md`). The gem has been tested
+end to end on three
 real models: DeepSeek V4.1 Flash (11 of 12 questions right, 33 zooms), Claude Haiku 4.5
 (10 of 12 right, 31 zooms) and GLM-5.3 Flash (10 of 12 right, 26 zooms), each as both
 compactor and reader, on a small synthetic log (14 entries, 12 questions). That is a smoke
@@ -148,6 +150,103 @@ Compresses an existing long thread at batch prices with `RubyLLM::Batch` (`ask_l
 Call `submit` again after `collect!` when the thread is longer than one batch covers:
 later levels become ready as their children finish.
 
+A provider batch job is not a chat completions call. When `required_protocol` is set (see
+below), `submit` and `collect!` raise `ProtocolError`; load the thread with `tree.append` and
+`Pump::Runner` instead.
+
+### Encrypting the stored text
+
+The text columns (`ric_entries.text`, the original messages, and `ric_nodes.text`, the summary
+lines) can use Active Record Encryption. Set up the keys first (`bin/rails
+db:encryption:init`, then put them in your credentials), then turn it on in an initializer:
+
+```ruby
+# config/initializers/infinite_context.rb
+RubyLLM::InfiniteContext.encrypt_text = true
+```
+
+Rules:
+
+- **Set it before the app writes a memory row.** It works if the gem's models load before or
+  after the initializer. The models are plain classes that Zeitwerk does not reload, so the
+  setting holds for the life of the process. You cannot turn it off again in the same process.
+- **Without keys, the first write raises.** Nothing is stored as plain text by mistake.
+- **The gem never searches these columns in SQL.** It reads rows by id and works on the text
+  in Ruby, so non-deterministic encryption (the Rails default) is fine. Do not add your own
+  `LIKE` or `where(text: ...)` queries on them.
+- **Other columns are not encrypted.** They hold numbers, kinds and the tree key. `ric_views`
+  holds only `[level, i]` pairs. Make the tree key an opaque id (a record id, not an email
+  address or a phone number).
+- **Column size:** ciphertext is larger than the plain text (base64 and a JSON header, after
+  compression). The generator makes `text` columns, which have no practical limit on SQLite
+  and Postgres. On MySQL, change them to `mediumtext` or larger.
+- **Rows that exist already** stay plain text and cannot be read once encryption is on. Set
+  `config.active_record.encryption.support_unencrypted_data = true`, run
+  `RubyLLM::InfiniteContext::Entry.find_each(&:encrypt)` and the same for `Node`, then turn
+  that setting off again.
+
+If you prefer to declare it yourself, do it once per process, with a guard:
+
+```ruby
+# config/application.rb
+config.to_prepare do
+  [RubyLLM::InfiniteContext::Entry, RubyLLM::InfiniteContext::Node].each do |model|
+    model.encrypts :text unless Array(model.encrypted_attributes).include?(:text)
+  end
+end
+```
+
+`to_prepare` runs again on every code reload in development, and the gem's models are not
+reloaded. Without the guard, a second `encrypts :text` would wrap the column twice.
+
+### Requiring one protocol
+
+To make sure no chat the gem uses can reach another API, require the protocol at boot:
+
+```ruby
+RubyLLM::InfiniteContext.required_protocol = :chat_completions
+```
+
+Then every chat the gem builds or uses must have that protocol: the compactor (the pump and
+`PumpJob`) and each turn of `attach` and the `Model` concern, including chats that you build
+and pass in (for an `acts_as_chat` record, the chat its `to_llm` returns). A chat with another
+protocol, or with none, raises `RubyLLM::InfiniteContext::ProtocolError` before any request
+is sent and before the turn is logged. `BatchImport` always raises `ProtocolError` under
+this rule, before it logs or submits anything, because provider batch jobs are not chat
+completions calls. A chat with fallback models is accepted only when each fallback is a `RubyLLM::Model`
+on the same provider, because RubyLLM drops the protocol when a fallback changes provider.
+
+### A locked-down setup
+
+For an app that must keep message text private (Fireworks serverless, chat completions only,
+encrypted storage):
+
+```ruby
+# config/initializers/infinite_context.rb
+fireworks = RubyLLM.context do |config|
+  config.openai_api_key = Rails.application.credentials.fireworks_api_key
+  config.openai_api_base = "https://api.fireworks.ai/inference/v1"
+end
+wire = { provider: :openai, protocol: :chat_completions,
+         assume_model_exists: true, context: fireworks }
+
+RubyLLM::InfiniteContext.required_protocol = :chat_completions
+RubyLLM::InfiniteContext.compactor_chat_options = wire
+RubyLLM::InfiniteContext.encrypt_text = true
+```
+
+Pass the same `wire` as `chat_options:` to `attach`, or set `protocol`, `provider` and
+`context` on the `acts_as_chat` record.
+
+Load old threads with `append` and the pump, not `BatchImport` (batch jobs are not chat
+completions, so `BatchImport` refuses under this setup):
+
+```ruby
+tree = RubyLLM::InfiniteContext::Tree.for("thread-42", compactor: "accounts/fireworks/models/glm-5p3-flash")
+old_messages.each { |m| tree.append(m.role == "assistant" ? :assistant : :user, m.content) }
+RubyLLM::InfiniteContext::Pump::Runner.new(tree).run   # plain chat completions, normal prices
+```
+
 ## How it works
 
 - **Log** (`ric_entries`): append-only, never updated or deleted.
@@ -189,7 +288,9 @@ machinery with no API calls. No client data is used anywhere in the corpus. See
 
 ```
 bin/setup
+rake            # the tests, the tests again with encryption on, then standard
 rake test
+rake test:encrypted
 rake standard
 ```
 

data/lib/ruby_llm/infinite_context/batch_import.rb

@@ -31,7 +31,12 @@ module RubyLLM
       # Appends `messages` (role/content pairs) to the log and submits the
       # ready nodes as one batch. Returns nil when nothing needs a model
       # call. When RubyLLM::Batch is unavailable, use Pump::Runner instead.
+      #
+      # With InfiniteContext.required_protocol set, raises ProtocolError
+      # before it logs or sends anything: a provider batch job is not a chat
+      # completions call.
       def submit(messages)
+        refuse_batch_under_required_protocol!
         import_messages(messages)
         chats = []
         nodes = []
@@ -56,6 +61,7 @@ module RubyLLM
       # FIRST: a missing, empty or short result fails the whole collect and
       # stores nothing, so a partial batch never half-populates the tree.
       def collect!(submission, batch)
+        refuse_batch_under_required_protocol!
         raise Error, "batch is not complete (#{batch.status})" unless batch.complete?
 
         messages = batch.messages
@@ -80,6 +86,15 @@ module RubyLLM
 
       private
 
+      def refuse_batch_under_required_protocol!
+        required = InfiniteContext.required_protocol
+        return if required.nil?
+
+        raise ProtocolError, "BatchImport uses provider batch jobs (RubyLLM::Batch), which are not " \
+          "#{required.inspect} calls, and RubyLLM::InfiniteContext.required_protocol is #{required.inspect}. " \
+          "Load the thread with tree.append for each message, then Pump::Runner.new(tree).run."
+      end
+
       def import_messages(messages)
         messages.each do |m|
           role = (m[:role] || m["role"] || :user).to_s
@@ -148,9 +163,9 @@ module RubyLLM
         chat = if @chat_factory
           @chat_factory.call
         else
-          ChatOptions.build(@model, @chat_options || InfiniteContext.compactor_chat_options)
+          ChatOptions.build(@model, @chat_options || InfiniteContext.compactor_chat_options, role: "batch import")
         end
-        chat.with_instructions(Prompts::COMPACT_SYSTEM)
+        ChatOptions.check!(chat, "batch import").with_instructions(Prompts::COMPACT_SYSTEM)
       end
 
       def provider_name(batch)

data/lib/ruby_llm/infinite_context/chat_options.rb

@@ -15,6 +15,10 @@ module RubyLLM
     # (POST {base}/responses) by default. Fireworks and most other
     # OpenAI-compatible services only offer chat completions, so pass
     # `protocol: :chat_completions` for them. See the README.
+    #
+    # A host app can REQUIRE one protocol for every chat the gem builds or
+    # uses (see InfiniteContext.required_protocol=). Then a chat with any
+    # other protocol, or none, raises ProtocolError before a request.
     module ChatOptions
       KEYS = %i[provider protocol assume_model_exists context].freeze
 
@@ -33,10 +37,72 @@ module RubyLLM
       end
 
       # RubyLLM.chat (or context.chat) with the options passed through.
-      def build(model, options = nil)
+      # With a required protocol, the options are checked BEFORE the chat is
+      # built and the built chat is checked after.
+      def build(model, options = nil, role: "chat")
         options = normalize(options).dup
+        check_option!(options[:protocol], role)
         context = options.delete(:context)
-        (context || RubyLLM).chat(model: model, **options)
+        check!((context || RubyLLM).chat(model: model, **options), role)
+      end
+
+      # Raises ProtocolError when a protocol is required and `protocol` is
+      # not it. Does nothing when no protocol is required.
+      def check_option!(protocol, role)
+        required = InfiniteContext.required_protocol
+        return if required.nil? || protocol.to_s == required.to_s
+
+        raise ProtocolError, "the #{role} options name protocol #{protocol.inspect}, but " \
+          "RubyLLM::InfiniteContext.required_protocol is #{required.inspect}; pass protocol: #{required.inspect}"
+      end
+
+      # Checks a chat the gem is about to use. Returns the chat. When a
+      # protocol is required, the chat must use it (none is a failure), and
+      # every fallback model must stay on the chat's provider (RubyLLM drops
+      # the protocol when a fallback moves to another provider). A chat whose
+      # protocol cannot be read fails too.
+      #
+      # An acts_as_chat record sends through its memoized `to_llm` chat, not
+      # through its `protocol` attribute, so for a record the `to_llm` chat
+      # is the one checked.
+      def check!(chat, role)
+        required = InfiniteContext.required_protocol
+        return chat if required.nil?
+
+        sender = chat.respond_to?(:to_llm) ? chat.to_llm : chat
+        actual = protocol_of(sender, role)
+        unless actual.to_s == required.to_s
+          raise ProtocolError, "the #{role} chat uses protocol #{actual.inspect}, but " \
+            "RubyLLM::InfiniteContext.required_protocol is #{required.inspect}; build it with protocol: #{required.inspect}"
+        end
+        check_fallbacks!(sender, role)
+        chat
+      end
+
+      def protocol_of(chat, role)
+        if defined?(RubyLLM::Chat) && chat.is_a?(RubyLLM::Chat)
+          chat.respond_to?(:protocol) ? chat.protocol : chat.instance_variable_get(:@protocol)
+        elsif chat.respond_to?(:protocol)
+          chat.protocol
+        else
+          raise ProtocolError, "cannot read the protocol of the #{role} chat (#{chat.class}), " \
+            "and RubyLLM::InfiniteContext.required_protocol is set"
+        end
+      end
+
+      def check_fallbacks!(chat, role)
+        fallbacks = chat.respond_to?(:fallbacks) ? Array(chat.fallbacks) : []
+        return if fallbacks.empty?
+
+        slug = (chat.respond_to?(:provider) && chat.provider.respond_to?(:slug)) ? chat.provider.slug.to_s : nil
+        fallbacks.each do |fallback|
+          provider = fallback.respond_to?(:provider) ? fallback.provider&.to_s : nil
+          next if slug && provider == slug
+
+          raise ProtocolError, "the #{role} chat has a fallback (#{fallback.respond_to?(:id) ? fallback.id : fallback}) " \
+            "that does not name the chat's provider #{slug.inspect}; with required_protocol set, every fallback " \
+            "must be a RubyLLM::Model on the same provider"
+        end
       end
     end
 
@@ -54,6 +120,20 @@ module RubyLLM
         @compactor_chat_options = ChatOptions.normalize(options)
       end
 
+      # The protocol every chat the gem builds or uses must have, or nil (the
+      # default: no rule). Set it once at boot:
+      #
+      #   RubyLLM::InfiniteContext.required_protocol = :chat_completions
+      #
+      # Then the compactor (pump, PumpJob), BatchImport and every turn of a
+      # Manager (attach, the Model concern) raise ProtocolError when their
+      # chat has another protocol or none, before any request is sent.
+      attr_reader :required_protocol
+
+      def required_protocol=(protocol)
+        @required_protocol = protocol&.to_sym
+      end
+
       # Attaches a chat to a memory tree; see Manager.attach.
       def attach(...) = Manager.attach(...)
     end

data/lib/ruby_llm/infinite_context/compactor.rb

@@ -55,7 +55,7 @@ module RubyLLM
         @model = model
         @chat_options = chat_options && ChatOptions.normalize(chat_options)
         @chat_factory = chat_factory ||
-          -> { ChatOptions.build(@model, @chat_options || InfiniteContext.compactor_chat_options) }
+          -> { ChatOptions.build(@model, @chat_options || InfiniteContext.compactor_chat_options, role: "compactor") }
       end
 
       # Returns [text, tries].
@@ -89,7 +89,7 @@ module RubyLLM
       end
 
       def ask(context, step)
-        chat = @chat_factory.call
+        chat = ChatOptions.check!(@chat_factory.call, "compactor")
         chat = chat.with_instructions(Prompts::COMPACT_SYSTEM) if chat.respond_to?(:with_instructions)
         # The view lines so far are staged WITHOUT a request (ask_later): they
         # ride along with the step in the one request that `ask` makes. A

data/lib/ruby_llm/infinite_context/encryption.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module InfiniteContext
+    # Active Record Encryption on the text columns of the memory tables:
+    # ric_entries.text (the original messages) and ric_nodes.text (the
+    # summary lines). The other columns hold numbers, kinds, labels and the
+    # tree key, not message text; ric_views.parts holds only [level, i]
+    # pairs. Keep the tree key an opaque id (a record id, not a phone number
+    # or an email address): it is not encrypted, because the gem finds trees
+    # by key.
+    #
+    #   # config/initializers/infinite_context.rb
+    #   RubyLLM::InfiniteContext.encrypt_text = true
+    #
+    # The encryption is non-deterministic (the Rails default). The gem never
+    # searches or filters on these columns in SQL: it reads them by id and
+    # works on the text in Ruby, so nothing breaks.
+    #
+    # Order rule: set it before the app writes a memory row, in an
+    # initializer or at boot. It works whether the models are loaded before
+    # or after the setting (the gem's models are plain classes, not reloaded
+    # by Zeitwerk). Once on, it stays on for the process: setting it to false
+    # after it was true raises Error (even before the models load).
+    module Encryption
+      COLUMNS = {"Entry" => :text, "Node" => :text}.freeze
+
+      module_function
+
+      # Declares `encrypts` on every loaded model that does not have it yet.
+      # Safe to call more than once.
+      def apply!
+        return unless InfiniteContext.encrypt_text?
+
+        each_model do |model, column|
+          next if declared?(model, column)
+
+          model.encrypts column
+        end
+      end
+
+      # True when a loaded gem model encrypts its text column.
+      def applied?
+        found = false
+        each_model { |model, column| found ||= declared?(model, column) }
+        found
+      end
+
+      def declared?(model, column)
+        Array(model.encrypted_attributes).include?(column)
+      end
+
+      def each_model
+        COLUMNS.each do |name, column|
+          next unless InfiniteContext.const_defined?(name, false)
+
+          model = InfiniteContext.const_get(name, false)
+          yield model, column if model.respond_to?(:encrypts)
+        end
+      end
+    end
+
+    class << self
+      def encrypt_text? = @encrypt_text == true
+
+      # Turns Active Record Encryption on for the gem's text columns. See
+      # Encryption for the order rule. Needs Active Record Encryption keys
+      # (bin/rails db:encryption:init); without them the first write raises.
+      def encrypt_text=(value)
+        on = value ? true : false
+        if !on && (@encrypt_text == true || Encryption.applied?)
+          raise Error, "encrypt_text cannot be turned off once it is on (restart the process)"
+        end
+
+        @encrypt_text = on
+        Encryption.apply!
+      end
+    end
+  end
+end

data/lib/ruby_llm/infinite_context/manager.rb

@@ -52,11 +52,12 @@ module RubyLLM
       end
 
       # One turn: log the user's message, ask with the view as instructions,
-      # log the reply, pump. A fresh Turn guards and caps the zooms.
+      # log the reply, pump. A fresh Turn guards and caps the zooms. The
+      # chat is built (and its protocol checked) before anything is logged.
       def turn(text)
+        chat = ChatOptions.check!(@chat_factory.call, "turn")
         tree.append(:user, text)
         turn = Turn.new
-        chat = @chat_factory.call
         chat.with_instructions("#{Prompts::VIEW_GUIDE}\n\n#{render_view}")
         chat.with_tools(*Tools.for_turn(tree, turn))
         reply = chat.ask(text)

data/lib/ruby_llm/infinite_context/model.rb

@@ -57,7 +57,7 @@ module RubyLLM
         raise Error, "the record has no model_id yet" if model_id.to_s.empty?
 
         record = self
-        factory = -> { ChatOptions.build(record.model_id, Model.chat_options_for(record)) }
+        factory = -> { ChatOptions.build(record.model_id, Model.chat_options_for(record), role: "record") }
         Manager.attach(factory, key: "#{self.class.name}:#{id}", budget:, tokens:,
           compactor: options[:compactor], compactor_options: options[:compactor_options])
       end

data/lib/ruby_llm/infinite_context/models.rb

@@ -179,5 +179,8 @@ module RubyLLM
 
       belongs_to :tree, class_name: "RubyLLM::InfiniteContext::Tree"
     end
+
+    # encrypt_text may have been set before this file loaded.
+    Encryption.apply!
   end
 end

data/lib/ruby_llm/infinite_context/pump.rb

@@ -5,7 +5,8 @@ module RubyLLM
     # The compactor's scheduler. Builds every node that is not built, has its
     # sources, and has its whole context summarized (every view line before
     # the node's end is built). Up to JOBS at once; a failed node is retried
-    # up to `retries` times.
+    # up to `retries` times. A ProtocolError (see required_protocol) is a
+    # setup error: the run stops and raises it.
     module Pump
       # The nodes to start now, in order: levels from 0 up, and in each
       # level from the left. `built` and `busy` are sets of [level, i].
@@ -116,26 +117,34 @@ module RubyLLM
           threads = nodes.map do |node|
             Thread.new do
               ok = false
+              fatal = nil
               # In a Rails app each worker thread runs inside the executor (it
               # returns the thread's database connection when it ends).
               Pump.wrap_thread do
                 text, tries = @builder.build(*node)
                 @tree.store_node!(*node, text, tries:)
                 ok = true
+              rescue ProtocolError => e
+                # A setup error, not a flaky call: no retry, raised below.
+                fatal = e
               rescue => e
                 log("node #{TreeMath.label(*node)} failed: #{e.class}: #{e.message}")
               end
-              done << [node, ok]
+              done << [node, ok, fatal]
             end
           end
           # While this thread waits, the workers may autoload constants. With
           # reloading on (Rails development) that needs the load interlock, so
           # the wait must permit concurrent loads or the pass deadlocks.
-          Pump.waiting do
-            results = nodes.map { done.pop }
+          results = Pump.waiting do
+            out = nodes.map { done.pop }
             threads.each(&:join)
-            results
+            out
           end
+          fatal = results.map(&:last).compact.first
+          raise fatal if fatal
+
+          results.map { |node, ok, _| [node, ok] }
         end
 
         def log(message)

data/lib/ruby_llm/infinite_context/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module InfiniteContext
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/ruby_llm/infinite_context.rb

@@ -18,6 +18,9 @@ module RubyLLM
   module InfiniteContext
     class Error < StandardError; end
 
+    # A chat does not use RubyLLM::InfiniteContext.required_protocol.
+    class ProtocolError < Error; end
+
     NODE = 512              # target size of one summary line
     DEFAULT_VIEW_BUDGET = 128_000 # default consumer view budget, bytes
     COMPACT_VIEW_BUDGET = 24_000  # the compactor's own view, 16-32 KB
@@ -38,6 +41,7 @@ require_relative "infinite_context/tokens"
 require_relative "infinite_context/fold"
 require_relative "infinite_context/prompts"
 require_relative "infinite_context/chat_options"
+require_relative "infinite_context/encryption"
 require_relative "infinite_context/compactor"
 require_relative "infinite_context/pump"
 require_relative "infinite_context/cache_mark"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-infinite_context
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Christian Genco
@@ -66,6 +66,7 @@ files:
 - lib/ruby_llm/infinite_context/cache_mark.rb
 - lib/ruby_llm/infinite_context/chat_options.rb
 - lib/ruby_llm/infinite_context/compactor.rb
+- lib/ruby_llm/infinite_context/encryption.rb
 - lib/ruby_llm/infinite_context/engine.rb
 - lib/ruby_llm/infinite_context/fold.rb
 - lib/ruby_llm/infinite_context/manager.rb