ollama_chat 0.0.125 → 0.0.126

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3de94c682281a4667e89feee589883bd33acf082165f37ce443072117a773167
-  data.tar.gz: 94cccbb92af48198a70879cf1028a0aebfe0cda49e25ccd82352cb35d9054bf7
+  metadata.gz: 93612bbed949bff6bad6cf89f581b324165c0aa672f6f92b675b63a6a2dce7e0
+  data.tar.gz: 79aac9f7dada8df87035af5bdfd2913d16012af44a781b7a20c44a457163b313
 SHA512:
-  metadata.gz: d3bad30e34ad309fe6c2f2263802af2778eded9459affc6c6713c6383f58706fe54411e7a4b6f087c487718d0a6ea8e07e90dfed22ca1a64b563d207ce61287e
-  data.tar.gz: 8f9befaa4a6a519b8f7b4424f0d16380663b863e039f08142fc667b01ecb83aa989b9e635ea5373b22191c7ba8f568e97dd210d732d1d6d5099dd3e5cffb74ee
+  metadata.gz: 2eb715b50338ddb686e6aab7debd264591e1018216adef57146237a862a5f37f217a31bb481a724b4bb8fcc99144c1a40679e3048c64cb88f0eaaabd546661fc
+  data.tar.gz: 8fa30b91ba125939cd506078bcaf6c9549bb43aa6323f9186e0acae218c7814fd8add54aa75b39f907d4affc78889c52a45b2479ec57c4218d76e61e67843ed3

data/CHANGES.md

@@ -1,5 +1,95 @@
 # Changes
 
+## 2026-10-05 v0.0.126
+
+*   **Tool Registry Refactor**: Refactored the tool registry to store tool
+    classes instead of pre-built instances.
+    *   `registered_class(name)` now returns the class for `summary_template`
+        access.
+    *   `registered_tool(name, chat:)` instantiates a fresh instance bound to
+        the current session.
+    *   `Concern#initialize(chat)` injects the chat reference; all tools now
+        access config via `self.chat` instead of `opts[:chat]`.
+    *   Helper methods in `execute_shell`, `generate_image`,
+        `get_current_weather`, `get_ghr`, and `patch_file` now use `self.chat`
+        directly.
+    *   Migrated all tool specs to use `described_class.new(chat)` and
+        `.execute(tool_call)`.
+
+*   **Path Allowlists**: Moved path allowlists into tool parameter
+    descriptions.
+    *   Added `allowed_paths` to `tools/concern.rb` to return expanded,
+        existing paths for the calling tool's `allowed` config.
+    *   Removed `tool_paths_allowed` from `tool_calling.rb` and its spec.
+    *   Injected `allowed_paths.map(&:inspect).join(', ')` into the `path`,
+        `source`, and `destination` parameter descriptions of `delete_file`,
+        `move_file`, `patch_file`, `read_file`, and `write_file`.
+
+*   **RAG Handling & Runtime Info**: Relocated `collection_descriptions` from
+    `information.rb` to `rag_handling.rb`.
+    *   Removed `collections` key from `static_runtime_information_values` and
+        `default_config.yml`.
+    *   Migrated `static_runtime_information` and `dynamic_runtime_information`
+        from `String#%` to `named_placeholders_interpolate`.
+
+*   **Collection Commands**: Reworked collection clearing into three distinct
+    commands.
+    *   Split monolithic `clear_collection` into `clear_whole_collection`,
+        `clear_collection_tags`, and `clear_collection_sources`.
+    *   `clear_collection_tags` implements a two-level tag-to-source browser.
+    *   `clear_collection_sources` implements a source-to-tags browser.
+    *   Added `use_pager(force:)` keyword in `pager.rb` to bypass size checks
+        using `Float::INFINITY`.
+    *   Added `Kramdown::ANSI::Width.wrap(..., percentage: 90)` to pager views
+        for terminal-width wrapping.
+    *   Bumped `documentrix` minimum to **0.8.0** in `Rakefile` and
+        `ollama_chat.gemspec` for the new `records(tags:, sources:)` API.
+    *   Extended `/collection` regexp and completion for `clear sources`.
+
+*   **Memory Tools**: Enhanced memory management tools.
+    *   `memorize` now accepts an optional `update` kwarg (ISO timestamp tag)
+        to replace an existing memory entry, returning `replaced_timestamp` and
+        `replaced_text`.
+    *   `forget` now returns `forgotten_text` in the JSON response and includes
+        an 80-character snippet in the human-readable `message`.
+    *   Renamed `set_current_collection` to `set_documents_collection` in
+        `rag_handling.rb`, `session_management.rb`, and specs.
+    *   Made `current_collection` public in `RAGHandling`.
+    *   Enriched `search_knowledge` tool `collection` param with allowed
+        collections from `collection_descriptions` and current default.
+
+*   **Session Management**:
+    *   Derive memory trigger from persona at session apply by adding a
+        `trigger` block to `default_config.yml`.
+    *   Extracted `create_memory_collection` into `RAGHandling` as the single
+        canonical entry point.
+    *   In `SessionManagement#session_apply`, auto-derive the session trigger
+        from `initial_persona_name` and `config.trigger` when no explicit
+        trigger is set.
+    *   Advertise `C-u` random shortcut in the session prompt to clear prefill
+        and obtain a random session name.
+
+*   **Commands & UX**:
+    *   Added `-r` flag to `/compose` to quote the last assistant reply as an
+        `edit_text` pre-fill.
+    *   Removed the `confirm?` prompt before `compact_with_retry` in
+        `/conversation compact`; compaction now runs immediately.
+    *   Split `/collection clear` into `clear tags` subcommand and bare `clear`
+        routing to `clear_whole_collection`.
+
+*   **Tool Descriptions & Logging**:
+    *   Made `paste_into_editor` description imperative.
+    *   Documented bottom-up edit order in `patch_file` to prevent models from
+        incorrectly compensating for line shifts.
+    *   Log full `edits` array in `patch_file` tool info log payload instead of
+        just `edits_count`.
+    *   Strip ANSI codes from `run_tests` captured output using
+        `OllamaChat::Utils::StripANSI`.
+
+*   **Compatibility & Fixes**:
+    *   Include `persona_name` in the `default` system prompt template in
+        `default_config.yml`.
+
 ## 2026-10-03 v0.0.125
 
 ### Added

data/Rakefile

@@ -40,7 +40,7 @@ GemHadar do
 
   dependency             'excon',                 '~> 1.0'
   dependency             'ollama-ruby',           '~> 1.23'
-  dependency             'documentrix',           '>= 0.7.0'
+  dependency             'documentrix',           '>= 0.8.0'
   dependency             'unix_socks',            '>= 0.4'
   dependency             'rss',                   '~> 0.3'
   dependency             'term-ansicolor',        '~> 1.11'

data/lib/ollama_chat/commands.rb

@@ -427,15 +427,7 @@ module OllamaChat::Commands
         feedback("Denied.", type: :denied)
       end
     when 'compact'
-      if confirm?(
-          prompt: '🔔 Compact conversation? Old messages will be summarized. (y/n) ',
-          yes: /\Ay/i
-        )
-      then
-        compact_with_retry
-      else
-        feedback("Denied.", type: :denied)
-      end
+      compact_with_retry
     when 'summarize'
       opts = go_command('s', opts)
       summarize_conversation(sentence: opts[?s])
@@ -648,12 +640,12 @@ module OllamaChat::Commands
 
   command(
     name: :collection,
-    regexp: %r(^/collection(?:\s+(change|clear|list|rename|update(?: all)?|new|edit|delete|query))?((?:\s+-[er])*)?$),
-    complete: [ 'collection', %w[ change clear list rename update update\ all new edit delete query ] ],
+    regexp: %r(^/collection(?:\s+(change|clear(?: (?:tags|sources))?|list|rename|update(?: all)?|new|edit|delete|query))?((?:\s+-[er])*)?$),
+    complete: [ 'collection', %w[ change clear\ tags clear\ sources clear list rename update update\ all new edit delete query ] ],
     optional: true,
     help: <<~EOT
       📚 Manage RAG collections:
-         - change/clear/list/rename
+          - change/clear/clear tags/clear sources/list/rename
          - update: Re-index modified docs
          - update all: Re-index all collections
          - new: Interactively create a new collection
@@ -665,7 +657,11 @@ module OllamaChat::Commands
   ) do |subcommand, opts|
     case subcommand
     when 'clear'
-      clear_collection
+      clear_whole_collection
+    when 'clear tags'
+      clear_collection_tags
+    when 'clear sources'
+      clear_collection_sources
     when 'change'
       choose_collection(collection)
     when 'list'
@@ -829,12 +825,23 @@ module OllamaChat::Commands
 
   command(
     name: :compose,
-    regexp: %r(^/compose$),
+    regexp: %r(^/compose(\s+-r)?\s*$),
+    options: '[-r]',
     help: <<~EOT
       \u270D  Compose message in external editor
+         Options: -r pre-fill with quoted last assistant reply
     EOT
-  ) do
-    edit_text.full? or :next
+  ) do |opts|
+    opts = go_command('r', opts)
+    prefill = if opts[?r]
+      if msg = messages.find_last(content: true) { !_1.tool? && _1.role == 'assistant' }
+        msg.content.to_s.lines.map { "> #{_1}" }.join + "\n\n"
+      else
+        feedback('No assistant message to quote.', type: :warn)
+        next :next
+      end
+    end
+    edit_text(prefill).full? or :next
   end
 
   command(

data/lib/ollama_chat/compaction.rb

@@ -21,7 +21,7 @@ module OllamaChat::Compaction
     # @return [String] a short natural-language description of the call.
     def tool_summary_line(tool_name, result)
       default_summary = "was called."
-      klass           = OllamaChat::Tools.registered[tool_name.to_s]&.class
+      klass           = OllamaChat::Tools.registered_class(tool_name)
       klass&.summary_template(result:) || default_summary
     rescue StandardError
       default_summary

data/lib/ollama_chat/follow_chat.rb

@@ -180,7 +180,7 @@ class OllamaChat::FollowChat
         feedback(
           ("\n%s Execution of tool %s confirmed.\n\n" % [ symbol, bold { name } ])
         )
-        result = OllamaChat::Tools.registered[name].execute(tool_call, chat:)
+        result = OllamaChat::Tools.registered_tool(name, chat:).execute(tool_call)
         chat.log(:info, "Tool execution confirmed", data: { tool: name, confirmed: })
       end
 

data/lib/ollama_chat/information.rb

@@ -327,22 +327,6 @@ module OllamaChat::Information
     config.infobar.message.to_h
   end
 
-  # Retrieves a hash of collection names and their descriptions from the
-  # database.
-  #
-  # This is used to provide context to the AI model about available RAG
-  # collections.
-  #
-  # @return [Hash{String => String}] a hash mapping collection names to their
-  #   descriptions
-  def collection_descriptions
-    cols = models::Collection.where(enabled: true)
-      .select(:name, :description).order(:name)
-    cols.each_with_object({}) do |c, hash|
-      hash[c.name] = c.description
-    end
-  end
-
   # Generates a hash containing static runtime information.
   #
   # This method collects session-level constants including the user,
@@ -353,11 +337,9 @@ module OllamaChat::Information
   def static_runtime_information_values
     {
       client:               ,
-      collections:          JSON.pretty_generate(collection_descriptions),
       current_directory:    Pathname.pwd.expand_path.to_path,
       languages:            config.languages * ', ',
       location:             location.on?.full? { location_description } || 'n/a',
-      tool_paths_allowed:   JSON.pretty_generate(tool_paths_allowed),
       user:                 ,
     }
   end
@@ -369,7 +351,9 @@ module OllamaChat::Information
   #
   # @return [String] a formatted static runtime information string.
   def static_runtime_information
-    prompt(:static_runtime_info).to_s % static_runtime_information_values
+    prompt(:static_runtime_info).to_s.named_placeholders_interpolate(
+      static_runtime_information_values
+    )
   end
 
   # Returns a formatted string representing the estimated text length of
@@ -423,7 +407,9 @@ module OllamaChat::Information
   #
   # @return [String] the formatted dynamic runtime information string.
   def dynamic_runtime_information
-    prompt(:dynamic_runtime_info).to_s % dynamic_runtime_information_values
+    prompt(:dynamic_runtime_info).to_s.named_placeholders_interpolate(
+      dynamic_runtime_information_values
+    )
   end
 
   # Injects the current dynamic runtime information (the "heartbeat")

data/lib/ollama_chat/ollama_chat_config/default_config.yml

@@ -56,8 +56,6 @@ prompts:
       - Location: %{location}
       - Current directory is "%{current_directory}"
       - Client is %{client}.
-      - These tools have access to these allowed paths: %{tool_paths_allowed}
-      - Search in these collections with `search_knowledge`: %{collections}
     dynamic_runtime_info: |
       There is usually no reason to mention this information to the user unless
       asked about it.
@@ -424,7 +422,7 @@ prompts:
       To see the full output of any tool call above, use lookup_group
       with the group UUID in parentheses.
   system:
-    default: <%= OC::OLLAMA::CHAT::SYSTEM || "%{persona}\n\n%{runtime_info}".inspect %>
+    default: <%= OC::OLLAMA::CHAT::SYSTEM || "`persona_name`: %{persona_name}\n\n%{persona}\n\n%{runtime_info}".inspect %>
     persona: |
       `persona_name`: %{persona_name}
 
@@ -497,6 +495,10 @@ document_policy: importing
 persona:
   # Basename (without .md) of the default persona file in the personae directory.
   default_name: personal_assistant
+trigger:
+  enabled: true
+  prompt_name: memory_rerank
+  text_count: 3
 parsing:
   directory_structure_max_depth: 1
 think:

data/lib/ollama_chat/pager.rb

@@ -12,14 +12,17 @@ module OllamaChat::Pager
   # If the output would exceed the terminal's line capacity, it pipes the content
   # through an appropriate pager command (like 'less' or 'more').
   #
+  # @param force [Boolean] bypass the line-count threshold and always
+  #   invoke the pager, regardless of output length.
   # @yield A block that yields an IO object to write output to
   # @yieldparam [IO] the IO object to write to
-  def use_pager
+  def use_pager(force: false)
     command       = determine_pager_command
     output_buffer = StringIO.new
     yield output_buffer
     buffer = output_buffer.string
-    Kramdown::ANSI::Pager.pager(command:, lines: buffer.count(?\n)) do |output|
+    lines  = force ? Float::INFINITY : buffer.count(?\n)
+    Kramdown::ANSI::Pager.pager(command:, lines:) do |output|
       output.puts buffer
     end
   end

data/lib/ollama_chat/rag_handling.rb

@@ -32,7 +32,32 @@ module OllamaChat::RAGHandling
     models::Collection[name: collection.to_s]
   end
 
-  private
+  # Creates (or reuses) the persistent memory collection for a persona.
+  #
+  # The collection is named "memory-#{persona_name}" and is registered in
+  # the local database with an empty pattern list. If a collection with
+  # that name already exists, it is returned as-is without modification.
+  #
+  # This is the single canonical entry point for ensuring a persona's
+  # memory collection exists before it is referenced by the trigger
+  # mechanism, the `memorize`/`forget` tools, or any other consumer.
+  #
+  # @param persona_name [String] the persona stem (e.g. "miyu_pairing")
+  #   whose memory collection should be available.
+  # @return [String] the collection name (e.g. "memory-miyu_pairing").
+  def create_memory_collection(persona_name)
+    collection = "memory-#{persona_name}"
+
+    unless chat.database_collection?(collection)
+      models::Collection.create(
+        name:        collection,
+        description: "Memory for persona #{persona_name}",
+        patterns:    [],
+      )
+    end
+
+    collection
+  end
 
   # Returns the name of the currently active document collection.
   #
@@ -41,45 +66,209 @@ module OllamaChat::RAGHandling
     @documents.collection
   end
 
-  # Clears documents from the collection through an interactive user interface.
+  # Retrieves a hash of collection names and their descriptions from the
+  # database.
   #
-  # This method allows users to selectively clear documents by choosing
-  # specific tags from the current collection or to clear all documents in the
-  # collection. It provides a loop for multiple deletions until the user exits
-  # or completes a clear operation.
-  def clear_collection
+  # This is used to provide context to the AI model about available RAG
+  # collections.
+  #
+  # @return [Hash{String => String}] a hash mapping collection names to their
+  #   descriptions
+  def collection_descriptions
+    cols = models::Collection.where(enabled: true)
+      .select(:name, :description).order(:name)
+    cols.each_with_object({}) do |c, hash|
+      hash[c.name] = c.description
+    end
+  end
+
+  private
+
+  # The clear_whole_collection method confirms user intent to delete the entire
+  # collection, then clears all documents and logs the action, returning self
+  # on success.
+  #
+  # @return [ nil, OllamaChat::Chat ] when the user declines the confirmation
+  #   prompt, self otherwise.
+  def clear_whole_collection
+    if confirm?(prompt: '🔔 Really delete the whole collection? Are you sure? (y/n) ', yes: /\Ay/i)
+      @documents.clear
+      log(:info, "Collection cleared", data: { collection: })
+      feedback("Cleared collection #{bold{collection}}.", type: :info)
+      self
+    else
+      feedback('Denied.', type: :denied)
+      nil
+    end
+  end
+
+  # Clears documents from the collection through an interactive
+  # two-level tag browser.
+  #
+  # Level 1: choose a tag from the collection.
+  # Level 2: inspect records grouped by source, with preview (v) and
+  #   surgical clear (c) options.
+  def clear_collection_tags
     choose_with_state do
       loop do
-        tags = @documents.tags.to_a.unshift('[ALL]').unshift('[EXIT]')
+        display = @documents.tags.map(&:to_s).sort.unshift('[EXIT]')
         tag = choose_entry(
-          tags,
-          prompt: 'What obsolete records are to be excised from the annals? %s'
+          display,
+          prompt: 'Which tag to inspect? %s'
         )
         case tag
+        when nil, '[EXIT]'
+          feedback('Exiting chooser.')
+          break
+        else
+          records = @documents.records(tags: tag)
+          groups  = records.group_by { |r| r.source.full? || '(nil)' }
+
+          if groups.size == 1 && groups.values.first.size == 1
+            record  = groups.values.first.first
+            source  = record.source
+            snippet = record.text.strip[0, 72].inspect
+            label   = source ? "#{source} #{snippet}" : snippet
+            feedback(label, type: :info)
+            view_tag_records(tag, [record])
+            ask?(prompt: "  [c]lear / other to go back: ") =~ /\Ac/i or next
+            clear_tag_records(tag, source)
+          else
+            group_lines = []
+            group_map   = {}
+            groups.sort_by { |src, _| src }.each do |src, recs|
+              if recs.size == 1
+                snippet = recs.first.text.strip[0, 72].inspect
+                line = src == '(nil)' ? snippet : "#{src} #{snippet}"
+              else
+                line = "#{src} (#{recs.size} records)"
+              end
+              group_lines << line
+              group_map[line] = [src, recs]
+            end
+            group_lines.unshift('[back]')
+            chosen = choose_entry(
+              group_lines,
+              prompt: "Tag #{tag.to_s.gsub(?%, '%%')} — which source group? %s"
+            )
+            next if chosen.nil? || chosen == '[back]'
+            src, recs = group_map[chosen]
+            action = ask?(prompt: "  [v]iew / [c]lear / other to go back: ")
+            case action
+            when /\Av/i
+              view_tag_records(tag, recs)
+            when /\Ac/i
+              clear_tag_records(tag, src == '(nil)' ? nil : src)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # Renders tag-filtered records in the pager.
+  def view_tag_records(tag, records)
+    use_pager(force: true) do |output|
+      output.puts "#{bold{tag}} (#{records.size} records)"
+      output.puts
+      records.each do |record|
+        output.puts kramdown_ansi_parse(<<~EOT)
+          **#{record.source}**
+          ```
+          #{Kramdown::ANSI::Width.wrap(record.text.sub(/\n+\z/, ''), percentage: 90)}
+          ```
+          ---
+        EOT
+      end
+    end
+  end
+
+  # Clears records for a tag, using source_remove when a source is
+  # present, or clear(tags:) for memory entries (no source).
+  def clear_tag_records(tag, source)
+    if source
+      @documents.source_remove(source)
+    else
+      @documents.clear(tags: [ tag ])
+    end
+    log(:info, 'Tag cleared from collection',
+        data: { collection:, tag:, source: })
+    feedback(
+      "Cleared tag #{tag} from collection #{bold{collection}}.",
+      type: :info
+    )
+  end
+
+  # Removes source documents from the collection through an interactive
+  # user interface.
+  #
+  # Each source is displayed with its associated tags for context.
+  # Users can preview a source's records in a pager before confirming
+  # removal.
+  def clear_collection_sources
+    choose_with_state do
+      loop do
+        sources     = Set.new
+        source_tags = Hash.new { |h, k| h[k] = Set.new }
+        @documents.records.each do |record|
+          source = record.source.full? or next
+          sources.add(source)
+          source_tags[source].merge(record.tags)
+        end
+        display_map = {}
+        sources.each do |s|
+          tags = source_tags[s].map(&:to_s)
+          line = tags.any? ? "#{s}  [#{tags.join(', ')}]" : s
+          display_map[line] = s
+        end
+        display = display_map.keys
+        display.unshift('[EXIT]')
+        chosen = choose_entry(
+          display,
+          prompt: 'Which source to remove from the collection? %s'
+        )
+        case chosen
         when nil, '[EXIT]'
           feedback("Exiting chooser.")
           break
-        when '[ALL]'
-          if confirm?(prompt: '🔔 Are you sure? (y/n) ', yes: /\Ay/i)
-            @documents.clear
-            log(:info, "Collection cleared", data: { collection: })
-            feedback("Cleared collection #{bold{collection}}.", type: :info)
-            break
+        else
+          source = display_map[chosen]
+          action = ask?(prompt: "  [v]iew / [c]lear / other to go back: ")
+          case action
+          when /\Av/i
+            records = @documents.records(sources: [ source ])
+            use_pager do |output|
+              output.puts "#{bold{source}} (#{records.size} records)"
+              output.puts
+              records.each do |record|
+                output.puts kramdown_ansi_parse(<<~EOT)
+                  **[#{record.tags.join(', ')}]**
+                  ```
+                  #{Kramdown::ANSI::Width.wrap(record.text.sub(/\n+\z/, ''), percentage: 90)}
+                  ```
+                  ---
+                EOT
+              end
+            end
+          when /\Ac/i
+            @documents.source_remove(source)
+            log(:info, "Source removed from collection",
+                data: { collection:, source: })
+            feedback(
+              "Removed source #{source} from collection #{bold{collection}}.",
+              type: :info
+            )
           end
-        when /./
-          @documents.clear(tags: [ tag ])
-          log(:info, "Tag cleared from collection", data: { collection:, tag: })
-          feedback("Cleared tag #{tag} from collection #{bold{collection}}.", type: :info)
         end
       end
     end
   end
 
-  # Sets the current document collection.
+  # Sets the documents collection to collection.
   #
   # @param collection [String, Symbol] the name of the collection to set
   # @return [String, Symbol] the newly set collection name
-  def set_current_collection(collection)
+  def set_documents_collection(collection)
     @documents.collection = collection
   end
 

data/lib/ollama_chat/session_management.rb

@@ -163,7 +163,7 @@ module OllamaChat::SessionManagement
     session_name = nil
     loop do
       session_name = ask?(
-        prompt: "❓ Enter new session name #{action}, C-c ⇒ cancel: ",
+        prompt: "❓ Enter new session name #{action}, C-u ⇒ random, C-c ⇒ cancel: ",
         prefill: default_name
       )
       if session_name.nil?
@@ -264,7 +264,26 @@ module OllamaChat::SessionManagement
     end
   end
 
+  # Applies the loaded session to the chat context.
+  #
+  # Performs the post-lock setup sequence:
+  #   1. Updates the session's working directory to `Dir.pwd`.
+  #   2. Initializes the in-memory message history from the session
+  #      payload.
+  #   3. Repairs any orphaned group UUIDs in the message list.
+  #   4. Ensures the persistent memory collection for the session's
+  #      persona exists in the database (no-op if already present).
+  #
+  # Called from {#setup_session} after the session has been locked.
+  #
+  # @return [OllamaChat::Database::Models::Session] the applied session
+  #   instance.
   def session_apply
+    initial_persona_name.full? do |persona_name|
+      collection        = create_memory_collection(persona_name)
+      session.trigger.present? or
+        session.trigger = { collection => chat.config.trigger.to_h }
+    end
     session.update(working_directory: Dir.pwd)
     init_history
     repair_group_uuids
@@ -503,6 +522,7 @@ module OllamaChat::SessionManagement
     existing = session.trigger.to_h
 
     collection = nil
+
     choose_with_state do
       # Prefill with the first configured collection as a starting
       # point. Fine for the single-trigger case; with multiple
@@ -630,11 +650,11 @@ module OllamaChat::SessionManagement
         if session.lock?(chat: self)
           messages.read_conversation_jsonl(session.messages.to_s)
           if current_collection = session.current_collection.full? and
-            database_collection?(current_collection)
+              database_collection?(current_collection)
           then
-            set_current_collection(current_collection)
+            set_documents_collection(current_collection)
           else
-            set_current_collection(:default)
+            set_documents_collection(:default)
           end
           session.current_model.full? { use_model(_1) }
           set_default_persona_name(session.default_persona_name.full? || :none)

data/lib/ollama_chat/tool_calling.rb

@@ -55,7 +55,9 @@ module OllamaChat::ToolCalling
   # @return [ Hash ] a hash containing the registered tools
   def tools
     tools_support.off? and return []
-    enabled_tools.filter_map { OllamaChat::Tools.registered[_1]&.to_hash }
+    enabled_tools.filter_map {
+      OllamaChat::Tools.registered_tool(_1, chat: self)&.to_hash
+    }
   end
 
   # The default_enabled_tools method returns an array of tool names that are
@@ -181,21 +183,6 @@ module OllamaChat::ToolCalling
     end
   end
 
-  # The tool_paths_allowed method returns a hash mapping each enabled tool name
-  # to its list of allowed paths or patterns. @return [Hash] a hash where keys
-  # are tool names and values are the allowed path lists
-  def tool_paths_allowed
-    config.tools.functions.to_h.
-      select { |name, value| tool_enabled?(name) && value[:allowed].present? }.
-      sort_by(&:first).
-      each_with_object({}) do |(name, value), hash|
-        hash[name.to_s] = value[:allowed].filter_map do
-          pathname = Pathname.new(_1).expand_path
-          pathname.exist?.full? { pathname.to_path }
-        end
-      end
-  end
-
   private
 
   def handle_tool_call_results?(&block)