ollama_chat 0.0.113 → 0.0.115

data/spec/ollama_chat/tools/execute_grep_spec.rb

@@ -48,6 +48,9 @@ describe OllamaChat::Tools::ExecuteGrep do
     expect(json.cmd).to include('spec/assets')
     expect(json.result).to include('Hello World!')
     expect(json.message).to match(/Found some matches for "Hello World" in ".*spec\/assets"\./)
+    expect(described_class.summary_template(result:)).to match(
+      /Found some matches for "Hello World" in ".*spec\/assets"\./
+    )
   end
 
   it 'can be executed successfully with max_results parameter' do
@@ -80,6 +83,9 @@ describe OllamaChat::Tools::ExecuteGrep do
     expect(json.cmd).to include(' -m 5 ')
     expect(json.result).to match(/blub class blob/)
     expect(json.message).to match(/Found some matches for "class" in ".*spec\/assets"\./)
+    expect(described_class.summary_template(result:)).to match(
+      /Found some matches for "class" in ".*spec\/assets"\./
+    )
   end
 
   it 'can be executed successfully with max_results and ignore_case parameter' do
@@ -113,6 +119,9 @@ describe OllamaChat::Tools::ExecuteGrep do
     expect(json.cmd).to include(' -i ')
     expect(json.result).to match(/blub class blob/)
     expect(json.message).to match(/Found some matches for "class" in ".*spec\/assets"\./)
+    expect(described_class.summary_template(result:)).to match(
+      /Found some matches for "class" in ".*spec\/assets"\./
+    )
   end
 
   it 'can handle execution errors gracefully' do
@@ -145,6 +154,9 @@ describe OllamaChat::Tools::ExecuteGrep do
     expect(json.cmd).to include('grep')
     expect(json.result).to eq ''
     expect(json.message).to match(/No matches found for "nonexistent_pattern" in ".*spec\/assets"\./)
+    expect(described_class.summary_template(result:)).to match(
+      /No matches found for "nonexistent_pattern" in ".*spec\/assets"\./
+    )
   end
 
   it 'can handle non-existent paths gracefully' do
@@ -205,6 +217,7 @@ describe OllamaChat::Tools::ExecuteGrep do
     json = json_object(result)
     expect(json.error).to eq 'RuntimeError'
     expect(json.message).to eq 'my error'
+    expect(described_class.summary_template(result:)).to eq 'my error'
   end
 
   context 'when searching in spec/assets directory' do

data/spec/ollama_chat/tools/execute_ri_spec.rb

@@ -42,6 +42,8 @@ describe OllamaChat::Tools::ExecuteRI do
       expect(json.cmd).to include('ri')
       expect(json.cmd).to include(topic)
       expect(json.result).to eq 'Documentation text for Tins::Full#full?'
+      expect(described_class.summary_template(result:)).to eq \
+        'was called.'
     end
   end
 
@@ -59,6 +61,9 @@ describe OllamaChat::Tools::ExecuteRI do
 
       json = json_object(result)
       expect(json.error).to eq('OllamaChat::ToolFunctionArgumentError')
+      expect(json.message).to eq 'require a topic of ri'
+      expect(described_class.summary_template(result:)).to eq \
+        'require a topic of ri'
     end
   end
 
@@ -82,6 +87,9 @@ describe OllamaChat::Tools::ExecuteRI do
       json = json_object(result)
       expect(json.error).to eq('RuntimeError')
       expect(json.message).to include('my error')
+      expect(described_class.summary_template(result:)).to include(
+        'my error',
+      )
     end
   end
 end

data/spec/ollama_chat/tools/execute_shell_spec.rb

@@ -0,0 +1,232 @@
+describe OllamaChat::Tools::ExecuteShell do
+  let :chat do
+    OllamaChat::Chat.new(argv: chat_default_config)
+  end
+
+  connect_to_ollama_server
+
+  let :tool do
+    described_class.new
+  end
+
+  before do
+    allow(OllamaChat).to receive(:test_mode?).and_return(false)
+    allow(chat).to receive(:log)
+    allow(OC).to receive(:EDITOR?).and_return('vim')
+  end
+
+  def tool_call(command, monochrome: nil)
+    double('ToolCall', function: double(
+      name: 'execute_shell',
+      arguments: double('Args', command:, monochrome:)
+    ))
+  end
+
+  def stub_success(stdout: 'ok', stderr: '', exit_code: 0)
+    allow(chat).to receive(:edit_text).and_return('ls')
+    allow(chat).to receive(:confirm?).and_return('y')
+    allow(chat).to receive(:use_pager) { |&blk| blk.call(StringIO.new) }
+    allow(Open3).to receive(:capture3)
+      .and_return([stdout, stderr, double('s', exitstatus: exit_code)])
+  end
+
+  describe 'identity' do
+    it 'has the expected name' do
+      expect(tool.name).to eq 'execute_shell'
+    end
+
+    it 'provides a Tool instance' do
+      expect(tool.tool).to be_a(Ollama::Tool)
+    end
+
+    it 'can be converted to hash' do
+      expect(tool.to_hash).to be_a(Hash)
+    end
+  end
+
+  describe '#execute' do
+    it 'runs the command after editor review and confirmation' do
+      expect(chat).to receive(:edit_text)
+        .with('ls -l', hash_including(basename: %w[cmd .sh]))
+        .and_return('ls -l')
+      expect(chat).to receive(:confirm?).and_return('y')
+      allow(chat).to receive(:use_pager) { |&blk| blk.call(StringIO.new) }
+      expect(Open3).to receive(:capture3)
+        .with('sh', '-c', 'ls -l')
+        .and_return(['total 0', '', double('s', exitstatus: 0)])
+
+      result = tool.execute(tool_call('ls -l'), chat:)
+      json   = json_object(result)
+
+      expect(json.error).to be_nil
+      expect(json.exit_code).to eq 0
+      expect(json.stdout).to eq 'total 0'
+      expect(json.stderr).to eq ''
+      expect(json.command).to eq 'ls -l'
+      expect(described_class.summary_template(result:)).to include('ls -l')
+    end
+
+    it 'executes the command as edited in the editor' do
+      allow(chat).to receive(:use_pager) { |&blk| blk.call(StringIO.new) }
+      expect(chat).to receive(:edit_text)
+        .with('ls', anything)
+        .and_return('ls -la /tmp')
+      allow(chat).to receive(:confirm?).and_return('y')
+      expect(Open3).to receive(:capture3)
+        .with('sh', '-c', 'ls -la /tmp')
+        .and_return(['x', '', double('s', exitstatus: 0)])
+
+      result = tool.execute(tool_call('ls'), chat:)
+
+      expect(json_object(result).command).to eq 'ls -la /tmp'
+    end
+
+    it 'returns cancelled when the user answers n' do
+      allow(chat).to receive(:edit_text).and_return('rm -rf .')
+      expect(chat).to receive(:confirm?).and_return('n')
+      expect(Open3).not_to receive(:capture3)
+
+      result = tool.execute(tool_call('rm -rf .'), chat:)
+      json   = json_object(result)
+
+      expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
+      expect(json.message).to include('cancelled')
+      expect(json.command).to eq 'rm -rf .'
+    end
+
+    it 'returns instruct when the user answers i' do
+      allow(chat).to receive(:edit_text).and_return('rm -rf .')
+      allow(chat).to receive(:confirm?).and_return('i')
+      expect(chat).to receive(:ask?)
+        .and_return('Actually use the build dir, not root')
+      expect(Open3).not_to receive(:capture3)
+
+      result = tool.execute(tool_call('rm -rf .'), chat:)
+      json   = json_object(result)
+
+      expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
+      expect(json.command).to eq 'rm -rf .'
+      expect(json.message).to include('build dir')
+    end
+
+    it 'returns cancelled when the editor is abandoned (nil)' do
+      expect(chat).to receive(:edit_text).and_return(nil)
+      expect(chat).not_to receive(:confirm?)
+      expect(Open3).not_to receive(:capture3)
+
+      result = tool.execute(tool_call('ls'), chat:)
+      json   = json_object(result)
+
+      expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
+      expect(json.message).to include('cancelled')
+      expect(json.command).to eq 'ls'
+    end
+
+    it 'returns cancelled when the editor is cleared to empty' do
+      expect(chat).to receive(:edit_text).and_return('')
+      expect(chat).not_to receive(:confirm?)
+      expect(Open3).not_to receive(:capture3)
+
+      result = tool.execute(tool_call('ls'), chat:)
+      json   = json_object(result)
+
+      expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
+    end
+
+    it 'skips editor and confirm in test mode' do
+      expect(OllamaChat).to receive(:test_mode?).and_return(true)
+      expect(chat).not_to receive(:edit_text)
+      expect(chat).not_to receive(:confirm?)
+      expect(Open3).to receive(:capture3)
+        .with('sh', '-c', 'ls')
+        .and_return(['ok', '', double('s', exitstatus: 0)])
+
+      result = tool.execute(tool_call('ls'), chat:)
+
+      expect(json_object(result).exit_code).to eq 0
+    end
+
+    it 'displays output via use_pager after execution' do
+      stub_success(stdout: "file1\nfile2", stderr: '')
+      pager_output = nil
+      expect(chat).to receive(:use_pager) do |&blk|
+        io = StringIO.new
+        blk.call(io)
+        pager_output = io.string
+      end
+
+      tool.execute(tool_call('ls'), chat:)
+
+      expect(pager_output).to include('file1')
+      expect(pager_output).to include('file2')
+      expect(pager_output).to include('exit: 0')
+    end
+
+    it 'strips ANSI from stdout when monochrome is true' do
+      stub_success(stdout: "\e[32mgreen\e[0m", stderr: '')
+
+      result = tool.execute(tool_call('ls', monochrome: true), chat:)
+
+      expect(json_object(result).stdout).to eq 'green'
+    end
+
+    it 'keeps ANSI when monochrome is false' do
+      stub_success(stdout: "\e[32mgreen\e[0m", stderr: '')
+
+      result = tool.execute(tool_call('ls', monochrome: false), chat:)
+
+      expect(json_object(result).stdout).to eq "\e[32mgreen\e[0m"
+    end
+
+    it 'treats a nil monochrome as true (default)' do
+      stub_success(stdout: "\e[31mred\e[0m", stderr: '')
+
+      result = tool.execute(tool_call('ls', monochrome: nil), chat:)
+
+      expect(json_object(result).stdout).to eq 'red'
+    end
+
+    it 'reports the exit code and stderr on failure' do
+      stub_success(stdout: '', stderr: 'nope', exit_code: 2)
+
+      result = tool.execute(tool_call('false'), chat:)
+      json   = json_object(result)
+
+      expect(json.exit_code).to eq 2
+      expect(json.stderr).to eq 'nope'
+    end
+
+    it 'rejects a blank command' do
+      allow(chat).to receive(:edit_text)
+
+      result = tool.execute(tool_call(nil), chat:)
+      json   = json_object(result)
+
+      expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
+    end
+
+    it 'summary_template includes the command and exit code' do
+      result = {
+        stdout: 'x', stderr: '', exit_code: 0,
+        command: 'ls -l', message: 'ok',
+      }.to_json
+
+      summary = described_class.summary_template(result:)
+      expect(summary).to include('ls -l')
+      expect(summary).to include('exit 0')
+    end
+
+    it 'summary_template includes error message for cancelled' do
+      result = {
+        error:   'OllamaChat::ToolFunctionArgumentError',
+        command: 'rm -rf .',
+        message: 'Shell command cancelled by user: rm -rf .',
+      }.to_json
+
+      summary = described_class.summary_template(result:)
+      expect(summary).to include('cancelled')
+      expect(summary).to include('rm -rf .')
+    end
+
+  end
+end

data/spec/ollama_chat/tools/file_context_spec.rb

@@ -31,6 +31,8 @@ describe OllamaChat::Tools::FileContext do
     json = json_object(result)
     content_file = json.files[Pathname.pwd.join('spec/assets/example.rb').to_s].content
     expect(content_file).to include 'Hello World!'
+    expect(described_class.summary_template(result:))\
+      .to eq "was called."
   end
 
   it 'can handle execution errors gracefully' do
@@ -50,5 +52,8 @@ describe OllamaChat::Tools::FileContext do
 
     # Should still return a string (even if empty or minimal)
     expect(result).to be_a(String)
+    expect(described_class.summary_template(result:))\
+      .to eq "was called."
   end
+
 end

data/spec/ollama_chat/tools/gem_path_lookup_spec.rb

@@ -56,6 +56,8 @@ describe OllamaChat::Tools::GemPathLookup do
       json = json_object(result)
       expect(json.error).to eq 'RuntimeError'
       expect(json.message).to eq 'an error has happened'
+      expect(described_class.summary_template(result:))\
+        .to eq 'an error has happened'
     end
   end
 end

data/spec/ollama_chat/tools/generate_image_spec.rb

@@ -62,6 +62,8 @@ describe OllamaChat::Tools::GenerateImage do
       expect(json.status).to eq 'success'
       expect(json.url).to include('/api/view')
       expect(json.url).to include('filename=kitten_output.png')
+      expect(described_class.summary_template(result:)).to\
+        match(/Image successfully generated!/)
     end
 
     it 'returns an error when prompt is missing' do
@@ -72,6 +74,8 @@ describe OllamaChat::Tools::GenerateImage do
       json = json_object(result)
       expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
       expect(json.message).to include('require prompt argument')
+      expect(described_class.summary_template(result:)).to\
+        include('require prompt argument')
     end
 
     it 'returns an error when ComfyUI configuration is missing' do
@@ -83,6 +87,8 @@ describe OllamaChat::Tools::GenerateImage do
       json = json_object(result)
       expect(json.error).to eq 'OllamaChat::ConfigMissingError'
       expect(json.message).to include('Require env var OLLAMA_CHAT_TOOLS_IMAGE_GENERATOR_URL configuration')
+      expect(described_class.summary_template(result:)).to\
+        include('Failed to generate image:')
     end
 
     it 'returns a timeout error when polling fails' do
@@ -98,6 +104,8 @@ describe OllamaChat::Tools::GenerateImage do
       json = json_object(result)
       expect(json.error).to eq 'OllamaChat::OllamaChatError'
       expect(json.message).to include('took too long or failed')
+      expect(described_class.summary_template(result:)).to\
+        include('took too long or failed')
     end
 
     it 'handles API failures gracefully' do
@@ -112,6 +120,8 @@ describe OllamaChat::Tools::GenerateImage do
       json = json_object(result)
       expect(json.error).to eq 'OllamaChat::OllamaChatError'
       expect(json.message).to include('Failed to generate image: failed to trigger ComfyUI')
+      expect(described_class.summary_template(result:)).to\
+        include('Failed to generate image:')
     end
 
     it 'rescues generic exceptions' do
@@ -124,6 +134,8 @@ describe OllamaChat::Tools::GenerateImage do
       json = json_object(result)
       expect(json.error).to eq 'StandardError'
       expect(json.message).to include('Network crash')
+      expect(described_class.summary_template(result:)).to\
+        include('Failed to generate image:')
     end
   end
 

data/spec/ollama_chat/tools/generate_password_spec.rb

@@ -46,6 +46,9 @@ describe OllamaChat::Tools::GeneratePassword do
     expect(json.message).to eq(
       'Successfully generated a 16-character secure password using the default alphabet.'
     )
+    expect(described_class.summary_template(result:)).to eq(
+      'Successfully generated a 16-character secure password using the default alphabet.'
+    )
   end
 
   it 'can be executed successfully with bits parameter' do
@@ -134,6 +137,8 @@ describe OllamaChat::Tools::GeneratePassword do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
     expect(json.message).to eq 'require either bits or length of password'
+    expect(described_class.summary_template(result:))\
+      .to eq 'require either bits or length of password'
   end
 
   it 'can be converted t)o hash' do

data/spec/ollama_chat/tools/get_cve_spec.rb

@@ -44,6 +44,8 @@ describe OllamaChat::Tools::GetCVE do
     json = json_object(result)
     expect(json.id).to eq 'CVE-2023-12345'
     expect(json.description).to include('Test vulnerability description')
+    expect(described_class.summary_template(result:)).to eq \
+      'was called.'
   end
 
   it 'can handle execution errors gracefully' do
@@ -67,5 +69,7 @@ describe OllamaChat::Tools::GetCVE do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::HTTPError'
     expect(json.message).to eq 'request failed with status 404'
+    expect(described_class.summary_template(result:)).to eq \
+      'request failed with status 404'
   end
 end

data/spec/ollama_chat/tools/get_endoflife_spec.rb

@@ -45,6 +45,8 @@ describe OllamaChat::Tools::GetEndoflife do
     expect(json.cycle).to eq '3.1'
     expect(json.releaseDate).to eq '2023-05-01'
     expect(json.eol).to eq '2026-05-01'
+    expect(described_class.summary_template(result:)).to eq \
+      'was called.'
   end
 
   it 'can handle execution errors gracefully' do
@@ -68,5 +70,7 @@ describe OllamaChat::Tools::GetEndoflife do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::HTTPError'
     expect(json.message).to eq 'request failed with status 404'
+    expect(described_class.summary_template(result:)).to eq \
+      'request failed with status 404'
   end
 end

data/spec/ollama_chat/tools/get_ghr_spec.rb

@@ -54,6 +54,8 @@ describe OllamaChat::Tools::GetGHR do
     expect(json.repo).to eq repo
     expect(json.releases).to be_a Array
     expect(json.releases.first.version).to eq '1.0'
+    expect(described_class.summary_template(result:)).to eq \
+      'was called.'
   end
 
   it 'can be executed successfully for an overview' do
@@ -104,6 +106,8 @@ describe OllamaChat::Tools::GetGHR do
 
     expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
     expect(json.message).to include('Both user and repo must be provided')
+    expect(described_class.summary_template(result:)).to include \
+      'Both user and repo must be provided'
   end
 
   it 'can handle execution errors gracefully' do
@@ -132,6 +136,8 @@ describe OllamaChat::Tools::GetGHR do
 
     expect(json.error).to eq 'OllamaChat::HTTPError'
     expect(json.message).to eq 'request failed with status 404'
+    expect(described_class.summary_template(result:)).to eq \
+      'request failed with status 404'
   end
 
   it 'can be executed successfully for a specific repository with pagination' do

data/spec/ollama_chat/tools/get_location_spec.rb

@@ -41,6 +41,8 @@ describe OllamaChat::Tools::GetLocation do
     expect(json.latitude).to be_within(0.0001).of(40.7128)
     expect(json.longitude).to be_within(0.0001).of(-74.0060)
     expect(json.units).to eq 'metric'
+    expect(described_class.summary_template(result:))\
+      .to eq 'was called.'
   end
 
   it 'can handle execution errors gracefully' do
@@ -71,6 +73,8 @@ describe OllamaChat::Tools::GetLocation do
       result = described_class.new.execute(tool_call, chat:)
       # Should still be valid JSON even if location_data is nil
       expect { JSON.parse(result) }.to_not raise_error
+      expect(described_class.summary_template(result:))\
+        .to eq 'was called.'
     end
   end
 end

data/spec/ollama_chat/tools/get_rfc_spec.rb

@@ -44,6 +44,7 @@ describe OllamaChat::Tools::GetRFC do
     json = json_object(result)
     expect(json.rfc_id).to eq rfc_id
     expect(json.content).to include('RFC 1234')
+    expect(described_class.summary_template(result:)).to eq 'RFC 1234 was fetched.'
   end
 
   it 'can handle execution errors gracefully' do
@@ -67,5 +68,6 @@ describe OllamaChat::Tools::GetRFC do
     json = json_object(result)
     expect(json.error).to be_a String
     expect(json.message).to be_a String
+    expect(described_class.summary_template(result:)).to eq 'request failed with status 404'
   end
 end

data/spec/ollama_chat/tools/get_time_spec.rb

@@ -36,6 +36,8 @@ describe OllamaChat::Tools::GetTime do
     )
     expect(json.weekday).to be_present
     expect(json.message).to eq 'Good morning! It is currently 11:11 on Friday.'
+    expect(described_class.summary_template(result:)).to eq \
+      'Good morning! It is currently 11:11 on Friday.'
   ensure
     Time.dummy = nil
   end

data/spec/ollama_chat/tools/get_url_spec.rb

@@ -17,6 +17,7 @@ describe OllamaChat::Tools::GetURL do
     expect(described_class.new.to_hash).to be_a Hash
   end
 
+
   context "with a valid URL" do
     it "imports content from the URL" do
       tool_call = double(
@@ -39,6 +40,8 @@ describe OllamaChat::Tools::GetURL do
       json = json_object(result)
       expect(json.url).to eq('https://www.example.com/foo')
       expect(json.message).to eq('Received requested URL successfully.')
+      expect(described_class.summary_template(result:)).to eq \
+        'Received requested URL successfully.'
     end
   end
 
@@ -68,6 +71,8 @@ describe OllamaChat::Tools::GetURL do
       expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
       expect(json.message).to match(/scheme "file" not allowed/)
       expect(json.url).to eq url
+      expect(described_class.summary_template(result:)).
+        to match(/scheme "file" not allowed/)
     end
   end
 
@@ -93,6 +98,8 @@ describe OllamaChat::Tools::GetURL do
     json = json_object(result)
     expect(json.error).to eq 'RuntimeError'
     expect(json.message).to eq 'it somehow failed'
+    expect(described_class.summary_template(result:)).to eq \
+      'it somehow failed'
   end
 
   context 'with different document policies' do

data/spec/ollama_chat/tools/lookup_group_spec.rb

@@ -0,0 +1,111 @@
+describe OllamaChat::Tools::LookupGroup do
+  let :chat do
+    OllamaChat::Chat.new(argv: chat_default_config)
+  end
+
+  connect_to_ollama_server
+
+  let :tool do
+    described_class.new
+  end
+
+  let :uuid do
+    '0194a3f2-8c4d-7e1a-9b3c-abcdef012345'
+  end
+
+  before do
+    chat.messages << OllamaChat::Message.new(
+      role: 'user', content: 'Read the config file', group_uuid: uuid
+    )
+    chat.messages << OllamaChat::Message.new(
+      role: 'assistant', content: 'Sure, let me read it.', group_uuid: uuid
+    )
+    chat.messages << OllamaChat::Message.new(
+      role: 'tool', content: '{"path":"/tmp/config.yml","content":"key: value"}',
+      tool_name: 'read_file', group_uuid: uuid
+    )
+    chat.messages << OllamaChat::Message.new(
+      role: 'assistant', content: 'Here is the config.', group_uuid: uuid
+    )
+  end
+
+  it 'has the expected name' do
+    expect(tool.name).to eq 'lookup_group'
+  end
+
+  it 'provides a Tool instance' do
+    expect(tool.tool).to be_a(Ollama::Tool)
+  end
+
+  it 'can be converted to hash' do
+    expect(tool.to_hash).to be_a(Hash)
+  end
+
+  it 'returns the full messages of a matching group' do
+    tool_call = double(
+      'ToolCall',
+      function: double(
+        name: 'lookup_group',
+        arguments: double(group_uuid: uuid)
+      )
+    )
+
+    result = tool.execute(tool_call, chat:)
+    expect(result).to be_a(String)
+
+    json = json_object(result)
+    expect(json.group_uuid).to eq uuid
+    expect(json.messages.size).to eq 4
+    expect(json.message).to eq 'Retrieved 4 message(s) for group 0194a3f2-8c4d-7e1a-9b3c-abcdef012345.'
+    expect(json.messages[0]).to eq '[user] Read the config file'
+    expect(json.messages[1]).to eq '[assistant] Sure, let me read it.'
+    expect(json.messages[2]).to eq '[tool (read_file)] {"path":"/tmp/config.yml","content":"key: value"}'
+    expect(json.messages[3]).to eq '[assistant] Here is the config.'
+  end
+
+  it 'returns an error for a non-existent group' do
+    tool_call = double(
+      'ToolCall',
+      function: double(
+        name: 'lookup_group',
+        arguments: double(group_uuid: 'ffffffff-0000-0000-0000-000000000000')
+      )
+    )
+
+    result = tool.execute(tool_call, chat:)
+    json = json_object(result)
+    expect(json.error).to eq 'OllamaChat::OllamaChatError'
+    expect(json.message).to include('Group not found')
+    expect(json.message).to include('ffffffff-0000-0000-0000-000000000000')
+  end
+
+  it 'returns an error when group_uuid is empty' do
+    tool_call = double(
+      'ToolCall',
+      function: double(
+        name: 'lookup_group',
+        arguments: double(group_uuid: '')
+      )
+    )
+
+    result = tool.execute(tool_call, chat:)
+    json = json_object(result)
+    expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
+    expect(json.message).to eq 'group_uuid required'
+  end
+
+  it 'matches on the suffix of the group_uuid' do
+    tool_call = double(
+      'ToolCall',
+      function: double(
+        name: 'lookup_group',
+        arguments: double(group_uuid: 'abcdef012345')
+      )
+    )
+
+    result = tool.execute(tool_call, chat:)
+    json = json_object(result)
+    expect(json.group_uuid).to eq uuid
+    expect(json.message).to include('Retrieved 4 message(s)')
+  end
+end