ollama_chat 0.0.113 → 0.0.115

data/spec/ollama_chat/message_list_spec.rb

@@ -123,6 +123,235 @@ describe OllamaChat::MessageList do
       group = list.each_group.to_a.first
       expect(group.map(&:content)).to eq ['first', 'second', 'third']
     end
+
+    it 'filters messages correctly' do
+      list = described_class.new(chat)
+      uuid = 'filter-test'
+      list << OllamaChat::Message.new(role: 'user', content: 'first', group_uuid: uuid)
+      list << OllamaChat::Message.new(role: 'assistant', content: 'second', group_uuid: uuid)
+      list << OllamaChat::Message.new(role: 'user', content: 'third', group_uuid: uuid)
+
+      group = list.each_group(role: 'user').to_a.first
+      expect(group.map(&:content)).to eq ['first', 'third']
+    end
+  end
+
+  describe '#find_cut_point' do
+    before do
+      allow(chat).to receive(:think_strip).and_return double(on?: false)
+    end
+
+    def add_group(list, uuid, role, content)
+      list << OllamaChat::Message.new(
+        role:, content:, group_uuid: uuid
+      )
+    end
+
+    it 'returns nil when there are no non-system messages' do
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 100)).to be_nil
+    end
+
+    it 'returns the first non-system index when everything fits' do
+      add_group(list, 'g1', 'user', 'hello')       # idx 1, 2 tok
+      add_group(list, 'g1', 'assistant', 'world')  # idx 2, 2 tok
+      add_group(list, 'g2', 'user', 'hi')          # idx 3, 1 tok
+
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 10)).to eq 1
+    end
+
+    it 'cuts at the group whose addition reaches the budget' do
+      add_group(list, 'g1', 'user', 'hello')       # idx 1, 2 tok
+      add_group(list, 'g1', 'assistant', 'world')  # idx 2, 2 tok
+      add_group(list, 'g2', 'user', 'hi')          # idx 3, 1 tok
+
+      # budget 4: walking back → 1 < 4, 3 < 4, 5 >= 4 → cut at idx 1
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 4)).to eq 1
+
+      # budget 1: walking back → 1 >= 1 → cut at idx 3
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 1)).to eq 3
+    end
+
+    it 'treats multi-message groups as a single atomic unit' do
+      # Group A: 2 messages = 4 tokens
+      add_group(list, 'a', 'user', 'hello')
+      add_group(list, 'a', 'assistant', 'world')
+      # Group B: 1 message = 2 tokens
+      add_group(list, 'b', 'user', 'hi hi')
+
+      # budget 6: 4 + 2 = 6 >= 6 → cut at group A (idx 1)
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 6)).to eq 1
+
+      # budget 2: 2 >= 2 → cut at group B (idx 3)
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 2)).to eq 3
+
+      # budget 5: 2 < 5, 6 >= 5 → cut at group A (idx 1)
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 5)).to eq 1
+    end
+
+    it 'skips system messages when building groups' do
+      add_group(list, 's2', 'system', 'extra system')
+      add_group(list, 'g1', 'user', 'hello')
+
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 10)).to eq 2
+    end
+
+    it 'ignores messages before start' do
+      add_group(list, 'old', 'user', 'aaaaa')        # idx 1, 2 tok
+      add_group(list, 'old', 'assistant', 'bbbbb')   # idx 2, 2 tok
+      add_group(list, 'n1', 'user', 'hi')            # idx 3, 1 tok
+      add_group(list, 'n2', 'user', 'yo')            # idx 4, 1 tok
+
+      # start: 0 includes old group (4 tok):
+      #   budget 3: walk back → n2:1<3, n1:2<3, old:6>=3 → cut at 1
+      expect(list.find_cut_point(start: 0, keep_recent_tokens: 3)).to eq 1
+
+      # start: 3 excludes old group: only n1(1)+n2(1)=2 in window
+      #   budget 3: walk back → n2:1<3, n1:2<3 → no-op at 3
+      expect(list.find_cut_point(start: 3, keep_recent_tokens: 3)).to eq 3
+    end
+  end
+
+  describe '#find_summary' do
+    it 'returns nil when no summary exists' do
+      expect(list.find_summary).to be_nil
+    end
+
+    it 'returns the summary message when present' do
+      summary = OllamaChat::Message.new(
+        role: 'tool', tool_name: 'summary',
+        content: '<summary>test</summary>', group_uuid: 's1'
+      )
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'hello', group_uuid: 'g1'
+      )
+      list << summary
+
+      expect(list.find_summary).to be summary
+    end
+  end
+
+  describe '#compact!' do
+    before do
+      allow(chat).to receive(:think_strip).and_return double(on?: false)
+      allow(chat).to receive(:current_context_length).and_return 100
+      allow(chat).to receive(:compact_ratio_tokens)
+        .with(:keep_recent, 100).and_return 5
+      allow(chat).to receive(:context_usage)
+        .and_return '10.0 T of 100 T (10.0%)'
+      allow(chat).to receive(:conversation_length)
+        .and_return '1.0 KB / 0.3 KT'
+    end
+
+    it 'returns nil when there are no non-system groups' do
+      expect(list.compact!).to be_nil
+      expect(list.size).to eq 1
+    end
+
+    it 'returns self unchanged when only one group exists' do
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'hello', group_uuid: 'g1'
+      )
+      expect(list.compact!).to be_nil
+      expect(list.size).to eq 2
+    end
+
+    it 'inserts a summary message and preserves old messages' do
+      # g1: 1+1=2 tok, g2: 2+2=4 tok, g3: 1 tok → total 7
+      # budget 5: walk back → 1<5, 5>=5 → cut at g2.start=3
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'a', group_uuid: 'g1'
+      )
+      list << OllamaChat::Message.new(
+        role: 'assistant', content: 'b', group_uuid: 'g1'
+      )
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'hello', group_uuid: 'g2'
+      )
+      list << OllamaChat::Message.new(
+        role: 'assistant', content: 'world', group_uuid: 'g2'
+      )
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'hi', group_uuid: 'g3'
+      )
+
+      expect(chat).to receive(:log).with(:info, /Compaction:/, kind_of(Hash)).at_least(:once)
+
+      expect(chat).to receive(:summarize_for_compaction).with(
+        hash_including(previous_summary: nil)
+      ).and_return(['narrative', []])
+
+      before = list.size
+      list.compact!
+
+      expect(list.size).to eq before + 1
+      summary = list.messages.find { _1.tool_name == 'summary' }
+      expect(summary).not_to be_nil
+      expect(summary.role).to eq 'tool'
+      expect(summary.content).to eq 'narrative'
+    end
+
+    it 'passes existing summary as previous_summary on re-compaction' do
+      old_summary = OllamaChat::Message.new(
+        role: 'tool', tool_name: 'summary',
+        content:  'old',
+        group_uuid: 's1'
+      )
+      list << old_summary
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'a', group_uuid: 'g1'
+      )
+      list << OllamaChat::Message.new(
+        role: 'assistant', content: 'b', group_uuid: 'g1'
+      )
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'hello', group_uuid: 'g2'
+      )
+      list << OllamaChat::Message.new(
+        role: 'assistant', content: 'world', group_uuid: 'g2'
+      )
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'hi', group_uuid: 'g3'
+      )
+
+      expect(chat).to receive(:log).with(:info, /Compaction:/, kind_of(Hash)).at_least(:once)
+
+      expect(chat).to receive(:summarize_for_compaction).with(
+        hash_including(previous_summary: old_summary)
+      ).and_return(['new', []])
+
+      before = list.size
+      list.compact!
+
+      expect(list.size).to eq before
+      summaries = list.messages.select { _1.tool_name == 'summary' }
+      expect(summaries.size).to eq 1
+      expect(summaries.first.content).to eq 'new'
+    end
+
+    it 'calls sync' do
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'a', group_uuid: 'g1'
+      )
+      list << OllamaChat::Message.new(
+        role: 'assistant', content: 'b', group_uuid: 'g1'
+      )
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'hello', group_uuid: 'g2'
+      )
+      list << OllamaChat::Message.new(
+        role: 'assistant', content: 'world', group_uuid: 'g2'
+      )
+      list << OllamaChat::Message.new(
+        role: 'user', content: 'hi', group_uuid: 'g3'
+      )
+      allow(chat).to receive(:summarize_for_compaction)
+        .and_return(['x', []])
+
+      expect(chat).to receive(:log).with(:info, /Compaction:/, kind_of(Hash)).at_least(:once)
+
+      expect(list).to receive(:sync)
+      list.compact!
+    end
   end
 
   describe '.load_conversation' do

data/spec/ollama_chat/message_spec.rb

@@ -0,0 +1,143 @@
+describe OllamaChat::Message do
+  describe 'OllamaChat::MessageMixin' do
+    let :group_uuid do
+      '0194a3f2-8c4d-7e1a-b3c1-2f9e5a6b7c8d'
+    end
+
+    let :message do
+      described_class.new(
+        role: 'user',
+        content: 'Hello World',
+        thinking: 'Let me think about this...',
+      )
+    end
+
+    describe '#token_estimate' do
+      it 'excludes thinking when strip_thinking is true' do
+        # "Hello World" is 11 bytes
+        # 11 / 3.5 = 3.14 → ceil = 4
+        es = message.token_estimate(strip_thinking: true)
+        expect(es).to be_a OllamaChat::TokenEstimator::Estimate
+        expect(es.bytes).to eq 11
+        expect(es.tokens).to eq 4
+      end
+
+      it 'includes thinking content by default (strip_thinking: false)' do
+        es = message.token_estimate
+        # "Hello World" (11) + "Let me think about this..." (26) = 37 bytes
+        # 37 / 3.5 = 10.57 → ceil = 11
+        expect(es.bytes).to eq 37
+        expect(es.tokens).to eq 11
+      end
+
+      it 'handles nil content gracefully' do
+        msg = described_class.new(role: 'user', content: nil)
+        es = msg.token_estimate
+        expect(es.bytes).to eq 0
+        expect(es.tokens).to eq 0
+      end
+
+      it 'handles nil thinking gracefully' do
+        msg = described_class.new(role: 'user', content: 'Hi', thinking: nil)
+        es = msg.token_estimate
+        expect(es.bytes).to eq 2
+      end
+
+      it 'handles both nil content and thinking' do
+        msg = described_class.new(role: 'user', content: nil, thinking: nil)
+        es = msg.token_estimate
+        expect(es.bytes).to eq 0
+        expect(es.tokens).to eq 0
+      end
+    end
+
+    describe '#group_time' do
+      it 'returns nil when group_uuid is missing' do
+        expect(message.group_time).to be_nil
+      end
+
+      it 'extracts the timestamp from a UUIDv7' do
+        msg  = described_class.new(
+          role: 'user', content: 'Hi', group_uuid:,
+        )
+        expected = Time.parse('2025-01-26 19:49:29+0100')
+        expect(msg.group_time).to be_within(5).of(expected)
+      end
+
+      it 'returns a Time close to now for a freshly generated UUID' do
+        msg = described_class.new(role: 'user', content: 'Hi')
+        msg.initialize_group_uuid
+        diff = (Time.now - msg.group_time).abs
+        expect(diff).to be < 5.0
+      end
+    end
+
+    describe '#initialize_group_uuid' do
+      it 'generates a UUIDv7 when missing' do
+        msg = described_class.new(role: 'user', content: 'Hi')
+        expect(msg.group_uuid).to be_nil
+        msg.initialize_group_uuid
+        expect(msg.group_uuid).to match(/\A[0-9a-f-]{36}\z/)
+      end
+
+      it 'preserves an existing group_uuid' do
+        uuid = '0194a3f2-8c4d-7e1a-b3c1-2f9e5a6b7c8d'
+        msg = described_class.new(role: 'user', content: 'Hi', group_uuid: uuid)
+        msg.initialize_group_uuid
+        expect(msg.group_uuid).to eq uuid
+      end
+
+      it 'returns self for chaining' do
+        msg = described_class.new(role: 'user', content: 'Hi')
+        expect(msg.initialize_group_uuid).to be msg
+      end
+    end
+
+    describe '#tool?' do
+      it 'returns true when tool_name is present' do
+        msg = described_class.new(
+          role: 'tool', content: 'result', tool_name: 'read_file',
+        )
+        expect(msg.tool?).to be true
+      end
+
+      it 'returns false when tool_name is nil' do
+        expect(message.tool?).to be false
+      end
+    end
+
+    describe '#as_json' do
+      it 'includes sender_name and group_uuid when set' do
+        msg = described_class.new(
+          role: 'user', content: 'Hi', sender_name: 'Florian', group_uuid:
+        )
+        json = msg.as_json
+        expect(json[:sender_name]).to eq 'Florian'
+        expect(json[:group_uuid]).to  eq group_uuid
+      end
+
+      it 'omits nil sender_name and group_uuid' do
+        json = message.as_json
+        expect(json).not_to have_key(:sender_name)
+        expect(json).not_to have_key(:group_uuid)
+      end
+
+      it 'includes tool_calls when set' do
+        entries = [{ 'type' => 'tool', 'name' => 'read_file',
+                     'summary' => 'Read /etc/hosts', 'uuid' => 'aaaa1234',
+                     'time' => '2026-08-30 14:32' }]
+        msg = described_class.new(
+          role: 'tool', content: 'summary', tool_name: 'summary',
+          tool_calls: entries,
+        )
+        json = msg.as_json
+        expect(json[:tool_calls]).to eq entries
+      end
+
+      it 'handles tool_calls as nil without crashing' do
+        json = message.as_json
+        expect(json[:tool_calls]).to be_nil
+      end
+    end
+  end
+end

data/spec/ollama_chat/rag_handling_spec.rb

@@ -402,6 +402,7 @@ describe OllamaChat::RAGHandling do
         'new desc',             # description
         'lib/**/*.rb spec/*',   # patterns
       )
+      expect(chat).to receive(:confirm?).and_return(false)
 
       chat.edit_collection
 
@@ -422,6 +423,7 @@ describe OllamaChat::RAGHandling do
         nil,  # blank description
         '',   # empty patterns
       )
+      expect(chat).to receive(:confirm?).and_return(false)
 
       chat.edit_collection
 
@@ -437,6 +439,7 @@ describe OllamaChat::RAGHandling do
         blk.call
       end
       expect(chat).to receive(:ask?).and_return('new d', '')
+      expect(chat).to receive(:confirm?).and_return(false)
       expect_any_instance_of(col_model).to receive(:save).
         and_raise(Sequel::Error, 'db error')
       expect(STDERR).to receive(:puts).

data/spec/ollama_chat/system_prompt_management_spec.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 describe OllamaChat::SystemPromptManagement do
   let :chat do
     OllamaChat::Chat.new(argv: chat_default_config).expose

data/spec/ollama_chat/tools/browse_spec.rb

@@ -44,6 +44,8 @@ describe OllamaChat::Tools::Browse do
       "Opened \"https://www.example.com\" in browser."
     )
     expect(json.url).to eq 'https://www.example.com'
+    expect(described_class.summary_template(result:)).to eq \
+      "Opened \"https://www.example.com\" in browser."
   end
 
   it 'can handle execution errors gracefully' do
@@ -71,6 +73,8 @@ describe OllamaChat::Tools::Browse do
     expect(json.message).to eq(
       "Could not open \"https://nonexistent-domain-12345.com\" in browser."
     )
+    expect(described_class.summary_template(result:)).to eq \
+      "Could not open \"https://nonexistent-domain-12345.com\" in browser."
   end
 
   it 'can handle execution exceptions gracefully' do
@@ -93,6 +97,7 @@ describe OllamaChat::Tools::Browse do
     json = json_object(result)
     expect(json.error).to eq 'RuntimeError'
     expect(json.message).to eq 'some kind of exception'
+    expect(described_class.summary_template(result:)).to eq 'some kind of exception'
   end
 
   context 'when browser is configured' do
@@ -126,6 +131,8 @@ describe OllamaChat::Tools::Browse do
         "Opened \"https://www.example.com\" in browser."
       )
       expect(json.url).to eq 'https://www.example.com'
+      expect(described_class.summary_template(result:)).to eq \
+        "Opened \"https://www.example.com\" in browser."
     end
   end
 end

data/spec/ollama_chat/tools/compute_bmi_spec.rb

@@ -36,6 +36,9 @@ describe OllamaChat::Tools::ComputeBMI do
         expect(json.message).to match(
           /This BMI is 22\.8\d+, which falls into the Normal weight category\./
         )
+        expect(described_class.summary_template(result:)).to match(
+          /This BMI is 22\.8\d+/,
+        )
       end
 
       it 'calculates BMI correctly for Underweight' do
@@ -55,6 +58,9 @@ describe OllamaChat::Tools::ComputeBMI do
         expect(json.message).to match(
           /This BMI is 17\.5\d+, which falls into the Underweight category\./
         )
+        expect(described_class.summary_template(result:)).to match(
+          /This BMI is 17\.5\d+/,
+        )
       end
     end
 
@@ -76,6 +82,9 @@ describe OllamaChat::Tools::ComputeBMI do
         expect(json.message).to match(
           /This BMI is 21\.5\d+, which falls into the Normal weight category\./
         )
+        expect(described_class.summary_template(result:)).to match(
+          /This BMI is 21\.5\d+/,
+        )
       end
     end
 
@@ -94,6 +103,9 @@ describe OllamaChat::Tools::ComputeBMI do
 
         expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
         expect(json.message).to include 'no weight given'
+        expect(described_class.summary_template(result:)).to include(
+          'no weight given',
+        )
       end
 
       it 'returns error when height is zero' do
@@ -110,6 +122,9 @@ describe OllamaChat::Tools::ComputeBMI do
 
         expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
         expect(json.message).to include 'Height must be greater than zero'
+        expect(described_class.summary_template(result:)).to include(
+          'Height must be greater than zero',
+        )
       end
     end
   end

data/spec/ollama_chat/tools/concern_spec.rb

@@ -0,0 +1,77 @@
+describe OllamaChat::Tools::Concern do
+  # Use a tool that does NOT override `summary_template` for base-class tests.
+  let :tool_class do
+    OllamaChat::Tools::GetTime
+  end
+
+  let :tool do
+    tool_class.new
+  end
+
+  describe '.summary_template' do
+    it 'extracts the message field from valid JSON' do
+      result = { message: 'The current time is 12:00 UTC.' }.to_json
+      expect(tool_class.summary_template(result:))
+        .to eq 'The current time is 12:00 UTC.'
+    end
+
+    it 'returns the generic fallback when message is absent' do
+      result = { data: 'no-message-key' }.to_json
+      expect(tool_class.summary_template(result:))
+        .to eq 'was called.'
+    end
+
+    it 'returns the generic fallback for invalid JSON' do
+      expect(tool_class.summary_template(result: 'not json'))
+        .to eq 'was called.'
+    end
+
+    it 'returns the generic fallback for empty string' do
+      expect(tool_class.summary_template(result: ''))
+        .to eq 'was called.'
+    end
+  end
+
+  describe '#name' do
+    it 'returns the registered name' do
+      expect(tool.name).to eq tool_class.register_name
+    end
+  end
+
+  describe '#to_hash' do
+    it 'delegates to tool.to_hash' do
+      expect(tool.to_hash).to eq tool.tool.to_hash
+    end
+
+    it 'returns a hash with a function key' do
+      expect(tool.to_hash).to have_key(:function)
+    end
+  end
+
+  describe '#valid_json?' do
+    it 'returns a proc' do
+      expect(tool.valid_json?).to be_a Proc
+    end
+
+    it 'parses valid JSON from a temp file' do
+      tmp = Tempfile.new('test.json')
+      tmp.write({ key: 'value' }.to_json)
+      tmp.rewind
+
+      expect(tool.valid_json?.call(tmp)).to eq({ key: 'value' }.to_json)
+    ensure
+      tmp&.close!
+    end
+
+    it 'raises for empty content' do
+      tmp = Tempfile.new('empty.json')
+      tmp.write('')
+      tmp.rewind
+
+      expect { tool.valid_json?.call(tmp) }
+        .to raise_error(JSON::ParserError, 'require JSON data')
+    ensure
+      tmp&.close!
+    end
+  end
+end

data/spec/ollama_chat/tools/copy_to_clipboard_spec.rb

@@ -36,6 +36,7 @@ describe OllamaChat::Tools::CopyToClipboard do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
     expect(json.message).to eq 'no text given'
+    expect(described_class.summary_template(result:)).to eq 'no text given'
   end
 
   it 'can copy custom text to the clipboard' do
@@ -63,6 +64,8 @@ describe OllamaChat::Tools::CopyToClipboard do
     expect(json.error).to be_nil # No exception was raised
     expect(json.success).to be true
     expect(json.message).to eq 'The provided text has been successfully copied to the system clipboard.'
+    expect(described_class.summary_template(result:))\
+      .to eq 'The provided text has been successfully copied to the system clipboard.'
   end
 
   it 'can be executed with edit option' do
@@ -89,6 +92,8 @@ describe OllamaChat::Tools::CopyToClipboard do
     expect(json.error).to be_nil
     expect(json.success).to be true
     expect(json.message).to eq 'The provided text has been successfully copied to the system clipboard.'
+    expect(described_class.summary_template(result:))\
+      .to eq 'The provided text has been successfully copied to the system clipboard.'
   end
 
   it 'can handle execution errors gracefully' do
@@ -115,6 +120,8 @@ describe OllamaChat::Tools::CopyToClipboard do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::OllamaChatError'
     expect(json.message).to eq 'No response available to copy to the system clipboard.'
+    expect(described_class.summary_template(result:))\
+      .to eq 'No response available to copy to the system clipboard.'
   end
 
   it 'can handle execution exceptions gracefully' do
@@ -141,5 +148,6 @@ describe OllamaChat::Tools::CopyToClipboard do
     json = json_object(result)
     expect(json.error).to eq 'RuntimeError'
     expect(json.message).to eq 'some kind of exception'
+    expect(described_class.summary_template(result:)).to eq 'some kind of exception'
   end
 end

data/spec/ollama_chat/tools/delete_file_spec.rb

@@ -39,6 +39,8 @@ describe OllamaChat::Tools::DeleteFile do
     expect(json.success).to eq true
     expect(json.path).to eq Pathname.new(file_path).expand_path.to_s
     expect(json.backup).not_to be_nil
+    expect(described_class.summary_template(result:)).
+      to include('deleted successfully')
 
     # Verify file was actually deleted
     expect(File.exist?(file_path)).to be false
@@ -70,6 +72,8 @@ describe OllamaChat::Tools::DeleteFile do
     expect(json.error).to eq 'OllamaChat::InvalidPathError'
     expect(json.path).to eq '/etc/passwd'
     expect(json.message).to include('is not within allowed directories')
+    expect(described_class.summary_template(result:)).
+      to include('is not within allowed directories')
   end
 
   it 'can handle execution errors gracefully when file does not exist' do
@@ -94,6 +98,8 @@ describe OllamaChat::Tools::DeleteFile do
     # Either InvalidPathError (because check: :file fails) or Errno::ENOENT
     expect(json.success).to be_falsey
     expect(json.message).to include('Failed to delete file')
+    expect(described_class.summary_template(result:)).
+      to include('Failed to delete file')
   end
 
   it 'can handle exceptions gracefully' do
@@ -120,6 +126,8 @@ describe OllamaChat::Tools::DeleteFile do
     json = json_object(result)
     expect(json.error).to eq 'RuntimeError'
     expect(json.message).to eq 'Failed to delete file, RuntimeError: Unexpected error'
+    expect(described_class.summary_template(result:)).to eq \
+      'Failed to delete file, RuntimeError: Unexpected error'
   ensure
     File.delete(file_path) if File.exist?(file_path)
   end

data/spec/ollama_chat/tools/directory_structure_spec.rb

@@ -32,6 +32,8 @@ describe OllamaChat::Tools::DirectoryStructure do
     expect(result).to be_a(String)
     json = json_object(result)
     expect(json.size).to eq 24
+    expect(described_class.summary_template(result:)).to eq \
+      'was called.'
   end
 
   it 'can be executed successfully with no arguments (defaults)' do
@@ -76,6 +78,8 @@ describe OllamaChat::Tools::DirectoryStructure do
     json = json_object(result)
     expect(json.error).to eq 'Errno::ENOENT'
     expect(json.message).to eq 'No such file or directory @ dir_initialize - /nonexistent/path'
+    expect(described_class.summary_template(result:)).to eq \
+      'No such file or directory @ dir_initialize - /nonexistent/path'
   end
 
   it 'can be converted to hash' do