ollama_chat 0.0.113 → 0.0.115

data/lib/ollama_chat/compaction.rb

@@ -0,0 +1,289 @@
+# Provides compaction support for chat sessions. Mixed into `Chat`.
+#
+# Supplies configuration resolvers that derive concrete token budgets
+# from the `compaction:` config block (ratios of `num_ctx` with absolute
+# floors), the LLM-based summarization pipeline
+# (+summarize_for_compaction+), and the +tool_summary_line+ resolver
+# for per-tool summary templates.
+#
+# @see OllamaChat::OllamaChatConfig::DefaultConfig for the `compaction:`
+#   block structure (`reserve`, `keep_recent`, `summary`).
+module OllamaChat::Compaction
+  class << self
+    # Generates a one-line summary for a tool call result.
+    #
+    # Looks up the registered tool class and delegates to its
+    # `summary_template(result:)` class method. Falls back to a generic
+    # sentence if the tool is not registered or the template raises.
+    #
+    # @param tool_name [String] the registered name, e.g. `'read_file'`.
+    # @param result [String] the raw JSON result string from `execute`.
+    # @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&.summary_template(result:) || default_summary
+    rescue StandardError
+      default_summary
+    end
+  end
+
+  # Value object carrying the outcome of a successful +compact!+ call.
+  #
+  # @!attribute [r] context_before
+  #   @return [String] formatted context usage before compaction
+  # @!attribute [r] context_after
+  #   @return [String] formatted context usage after compaction
+  # @!attribute [r] candidates
+  #   @return [Integer] number of messages that were summarized
+  # @!attribute [r] candidate_size
+  #   @return [String] formatted size of the candidate block
+  # @!attribute [r] summary_size
+  #   @return [String] formatted size of the generated summary
+  # @!attribute [r] stored_total
+  #   @return [String] formatted full conversation length
+  Result = Data.define(
+    :context_before, :context_after,
+    :candidates, :candidate_size,
+    :summary_size, :stored_total
+  )
+
+  # Generates a context summary for the given messages via LLM.
+  #
+  # Serializes non-system messages into a structured prompt, calls the
+  # model via +generate+, and assembles the final summary with
+  # deterministic tool-call entries stored out-of-band.
+  #
+  # @param messages [Array<OllamaChat::Message>] the messages to summarize.
+  # @param previous_summary [OllamaChat::Message, nil] the previous summary
+  #   message for iterative re-compaction.
+  # @return [Array(String, Array<Hash>)] the assembled content and the
+  #   merged tool-call entries array.
+  def summarize_for_compaction(messages:, previous_summary: nil)
+    groups       = serialize_groups(messages)
+    tool_entries = build_tool_entries(messages)
+
+    es = OllamaChat::TokenEstimator.estimate(groups)
+    log(:info, "Compaction: #{messages.size} messages, " \
+      "#{es.tokens_formatted} (#{es.bytes_formatted}) groups")
+
+    narrative_prev = ''
+    old_tool_calls = []
+    if previous_summary
+      narrative_prev = extract_narrative(previous_summary.content)
+      old_tool_calls = extract_old_tool_calls(previous_summary)
+    end
+
+    narrative = call_summarizer(groups:, previous_summary: narrative_prev)
+    assemble_summary(narrative, tool_entries, old_tool_calls)
+  end
+
+  # Resolves the effective token budget for a concern given a context size.
+  #
+  # Computes `max(ratio * tokens, min_tokens).floor`, so the floor acts as
+  # a guaranteed minimum even for very small context windows.
+  #
+  # @param name [Symbol] the concern name, e.g. `:reserve`, `:keep_recent`,
+  #   or `:summary`.
+  # @param tokens [Integer] the context window size (`num_ctx`) to derive
+  #   the budget from.
+  # @return [Integer] the resolved token budget.
+  def compact_ratio_tokens(name, tokens)
+    [
+      compact_ratio(name).to_f * tokens,
+      compact_min_tokens(name).to_f,
+    ].max.floor
+  end
+
+  # Attempts compaction, prompting the user to retry on failure.
+  #
+  # +compact!+ is idempotent on failure: the LLM call (and thus any
+  # +CompactionError+) happens before the message list is mutated, so a
+  # retry always starts from a clean state.
+  #
+  # @return [Boolean] true if compaction succeeded, false if the user
+  #   declined to retry.
+  def compact_with_retry
+    result   = messages.compact!
+    session_sync
+    if result
+      report_compaction(result)
+    else
+      STDOUT.puts('Nothing to compact.')
+    end
+    return true
+  rescue OllamaChat::CompactionError => e
+    STDERR.puts "⚠️  Compaction failed: #{e.message}"
+    log(:error, "Compaction failed", data: {
+      model: @model,
+      ctx:   current_context_length,
+      size:  messages.size,
+    })
+    retry if confirm?(
+      prompt: '🔔 Retry compaction? (y/n) ',
+      yes: /\Ay/i
+    )
+    false
+  end
+
+  private
+
+  # Serializes non-system messages into a readable block for the prompt.
+  #
+  # @param messages [Array<OllamaChat::Message>] the messages to serialize.
+  # @return [String] a formatted block of message lines.
+  def serialize_groups(messages)
+    messages
+      .reject { _1.role == 'system' }
+      .map { |m| format_summary_line(m) }
+      .join("\n")
+  end
+
+  # Formats a single message as a summary line.
+  #
+  # @param msg [OllamaChat::Message] the message to format.
+  # @return [String] a single line describing the message.
+  def format_summary_line(msg)
+    tool_name = msg.tool_name.full?
+    parts  = +"[#{msg.role}]"
+    parts << " (#{tool_name})" if tool_name
+    parts << " (g:#{msg.group_uuid.to_s[-8..]})" if msg.group_uuid
+    if tool_name
+      line = OllamaChat::Compaction.tool_summary_line(tool_name, msg.content.to_s)
+      parts << " #{line}"
+    elsif msg.content.present?
+      parts << " #{msg.content.to_s.strip}"
+    end
+    parts
+  end
+
+  # Builds the deterministic tool-call entries from tool result messages.
+  #
+  # @param messages [Array<OllamaChat::Message>] the messages to scan.
+  # @return [Array<Hash>] tool-call entry hashes, empty if no tool results.
+  def build_tool_entries(messages)
+    messages.filter_map do |msg|
+      next unless tool_name = msg.tool_name.full?
+      next if tool_name == 'runtime_information'
+      uuid = msg.group_uuid.to_s[-8..]
+      summary = OllamaChat::Compaction.tool_summary_line(
+        tool_name, msg.content.to_s
+      )
+      time = msg.group_time&.strftime('%Y-%m-%d %H:%M')
+      {
+        'type'    => 'tool',
+        'name'    => tool_name,
+        'summary' => summary,
+        'uuid'    => uuid,
+        'time'    => time,
+      }
+    end
+  end
+
+  # Calls the LLM to generate the narrative portion of the summary.
+  #
+  # @param groups [String] the serialized groups block.
+  # @param previous_summary [String, nil] the prior summary for iteration.
+  # @return [String] the LLM-generated narrative text.
+  def call_summarizer(groups:, previous_summary:)
+    previous = previous_summary.to_s
+
+    prompt = prompt(:summarize, context: 'compaction').to_s % {
+      previous:, groups:
+    }
+    system = prompt(:system, context: 'compaction').to_s
+
+    es = OllamaChat::TokenEstimator.estimate(prompt)
+    log(:info, "Compaction: sending prompt " \
+      "#{es.tokens_formatted} (#{es.bytes_formatted}) to #{@model}")
+
+    response = Infobar.busy(
+      label: 'Compacting context…',
+      frames: :braille7,
+      output: STDOUT,
+    ) do
+      generate(system:, prompt:, think: true).strip
+    end
+
+    if response.empty?
+      log(:error, 'Compaction: LLM returned empty response')
+      raise OllamaChat::CompactionError,
+            'Summarization failed: model returned empty response'
+    end
+
+    res_es = OllamaChat::TokenEstimator.estimate(response)
+    log(:info, "Compaction: got response " \
+      "#{res_es.tokens_formatted} (#{res_es.bytes_formatted})")
+
+    response
+  end
+
+  # Assembles the final summary content and merged tool entries.
+  #
+  # @param narrative [String] the LLM-generated narrative.
+  # @param tool_entries [Array<Hash>] new tool-call entries from this pass.
+  # @param old_tool_entries [Array<Hash>] entries carried over from a
+  #   prior compaction.
+  # @return [Array(String, Array<Hash>)] the content string and the
+  #   merged entries array.
+  def assemble_summary(narrative, tool_entries, old_tool_entries = [])
+    all_tools    = old_tool_entries + tool_entries
+    tool_section = all_tools.map(&:to_json) * ?\n
+
+    template = prompt(:assemble, context: 'compaction').to_s
+    content  = template % { narrative:, tool_section: }
+
+    [content, all_tools]
+  end
+
+  # Extracts the narrative portion from a summary message's content.
+  #
+  # @param content [String, nil] the summary content.
+  # @return [String] the narrative text.
+  def extract_narrative(content)
+    content.to_s.sub(/\ntool_calls:\n.*\z/m, '').strip
+  end
+
+  # Returns the tool-call entries from a previous summary message.
+  #
+  # @param summary_msg [OllamaChat::Message] the previous summary message.
+  # @return [Array<Hash>] the tool-call entries, empty if none.
+  def extract_old_tool_calls(summary_msg)
+    summary_msg.tool_calls || []
+  end
+
+  # Returns the absolute minimum token floor for a given concern.
+  #
+  # @param name [Symbol] the concern name, e.g. `:reserve`, `:keep_recent`,
+  #   or `:summary`.
+  # @return [Integer] the configured `min_tokens` floor.
+  def compact_min_tokens(name)
+    config.compaction.attribute_get!(name).min_tokens
+  end
+
+  # Returns the fractional ratio (portion of `num_ctx`) for a given concern.
+  #
+  # @param name [Symbol] the concern name, e.g. `:reserve`, `:keep_recent`,
+  #   or `:summary`.
+  # @return [Float] the configured `ratio` value.
+  def compact_ratio(name)
+    config.compaction.attribute_get!(name).ratio
+  end
+
+  # Displays a compact compaction report to +STDOUT+ after the
+  # +Infobar.busy+ spinner has finished.
+  #
+  # Replaces the former bare "Conversation compacted." line with
+  # before/after context metrics, candidate volume, and summary size.
+  #
+  # @param result [Result] the compaction result from +compact!+.
+  def report_compaction(result)
+    STDOUT.puts(<<~EOT)
+      ✅ Conversation compacted.
+         Summarized:   #{result.candidates} messages (#{result.candidate_size})
+         Summary:      #{result.summary_size}
+         Context:      #{result.context_before} → #{result.context_after}
+         Stored total: #{result.stored_total}
+    EOT
+  end
+end

data/lib/ollama_chat/config_handling.rb

@@ -1,3 +1,5 @@
+require 'open3'
+
 # Provides functionality for handling configuration files and settings for
 # OllamaChat. It loads configuration from YAML files, supports environment
 # variable overrides, and offers methods to read and write configuration data.
@@ -20,6 +22,36 @@ module OllamaChat::ConfigHandling
     self.class.config
   end
 
+  # Returns the first enabled syntax checker whose suffixes match the
+  # given file's extension, or nil if no match.
+  #
+  # @param path [String, Pathname] the file path to check
+  # @return [ComplexConfig::Settings, nil] the matching checker config
+  def syntax_checker_for(path)
+    path = Pathname.new(path)
+    ext = path.extname.delete_prefix(?.).full? or return
+    config.syntax_checkers.attribute_values.each do |checker|
+      next unless checker.enabled
+      return checker if checker.suffixes.include?(ext)
+    end
+    nil
+  end
+
+  # Runs the syntax checker on the given file and returns a result hash.
+  #
+  # @param checker [ComplexConfig::Settings] the resolved checker config
+  # @param path [String, Pathname] the file to check
+  # @return [Hash, nil] { status:, output: } or nil if binary is missing
+  def run_syntax_check(checker, path)
+    _stdout, stderr, status = Open3.capture3(*checker.cmd, path.to_s)
+    {
+      status: status.success? ? 'pass' : 'fail',
+      output: stderr.strip
+    }
+  rescue Errno::ENOENT
+    nil
+  end
+
   private
 
   # The config= method assigns a new configuration object to the class.

data/lib/ollama_chat/database/migrations/010_add_enabled_to_collections.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table :collections do
+      add_column :enabled, :boolean, default: true, null: false
+    end
+  end
+end

data/lib/ollama_chat/database/models/app_state.rb

@@ -62,17 +62,8 @@ class OllamaChat::Database::Models::AppState < Sequel::Model(OllamaChat::DB)
 
     stored_fingerprint = stored&.dig('fingerprint')
 
-    hashes = {}
-    chat.config.prompts.to_h.each do |context, prompts|
-      prompts.each do |name, content|
-        hashes["#{context}/#{name}"] =
-          Digest::SHA256.hexdigest(content.to_s)
-      end
-    end
-
-    fingerprint = hashes.values.reduce(0) do |sum, hex|
-      sum ^ hex.to_i(16)
-    end.to_s(16)
+    hashes    = compute_hashes(chat.config.prompts)
+    fingerprint = fingerprint_from(hashes)
 
     return true if fingerprint == stored_fingerprint
 
@@ -88,23 +79,32 @@ class OllamaChat::Database::Models::AppState < Sequel::Model(OllamaChat::DB)
       removed.each { |k| STDERR.puts "  - #{k} (removed)" }
     elsif !OllamaChat.test_mode?
       STDERR.puts '⚠️  First run — storing prompt fingerprints.'
-      set(:prompt_defaults_fingerprint,
-          { fingerprint:, hashes:, computed_at: Time.now.iso8601 })
+      store_fingerprint(fingerprint, hashes)
       return true
     end
 
     prompt = <<~EOT.chomp << ' '
       Keep local prompts (stop nagging)?
-      Consider adopting via /prompt sync or /prompt reset. (y/n) %s
+      Consider adopting via /prompt sync or just ignore? (y/n) %s
     EOT
     if OllamaChat.test_mode? || chat.confirm?(prompt:, yes: /\Ay/i, timeout: 5)
-      set(:prompt_defaults_fingerprint,
-          { fingerprint:, hashes:, computed_at: Time.now.iso8601 })
+      store_fingerprint(fingerprint, hashes)
     end
 
     true
   end
 
+  # Acknowledges the current shipped-prompt state, suppressing the boot
+  # drift notification. Called after `/prompt sync` so the user is not
+  # nagged again on the next launch.
+  #
+  # @param chat [OllamaChat::Chat] the chat instance providing the config
+  def self.acknowledge(chat)
+    hashes      = compute_hashes(chat.config.prompts)
+    fingerprint = fingerprint_from(hashes)
+    store_fingerprint(fingerprint, hashes)
+  end
+
   # @!attribute [v] id
   #   @return [Integer] The primary key for the state entry.
   #
@@ -119,4 +119,36 @@ class OllamaChat::Database::Models::AppState < Sequel::Model(OllamaChat::DB)
   #
   # @!attribute [v] updated_at
   #   @return [Time, nil] The timestamp of the last update to the state.
+
+  private
+
+  # Builds a per-prompt SHA256 hash map from a prompts config object.
+  #
+  # @param prompts_config [OllamaChatConfig::Prompts] the config prompts
+  # @return [Hash{String => String}] mapping "context/name" → SHA256 hex
+  def self.compute_hashes(prompts_config)
+    prompts_config.to_h.each_with_object({}) do |(context, prompts), hashes|
+      prompts.each do |name, content|
+        hashes["#{context}/#{name}"] =
+          Digest::SHA256.hexdigest(content.to_s)
+      end
+    end
+  end
+
+  # Computes an XOR fingerprint from a hash map.
+  #
+  # @param hashes [Hash{String => String}] the per-prompt SHA256 hex values
+  # @return [String] the XOR-combined fingerprint as a hex string
+  def self.fingerprint_from(hashes)
+    hashes.values.reduce(0) { |sum, hex| sum ^ hex.to_i(16) }.to_s(16)
+  end
+
+  # Stores the fingerprint and hash map under the standard state key.
+  #
+  # @param fingerprint [String] the XOR fingerprint
+  # @param hashes [Hash{String => String}] the per-prompt hash map
+  def self.store_fingerprint(fingerprint, hashes)
+    set(:prompt_defaults_fingerprint,
+        { fingerprint:, hashes:, computed_at: Time.now.iso8601 })
+  end
 end

data/lib/ollama_chat/database/models/session.rb

@@ -54,8 +54,7 @@ class OllamaChat::Database::Models::Session < Sequel::Model(OllamaChat::DB)
   #
   # @return [OllamaChat::TokenEstimator::Estimate] the estimated token and byte counts
   def estimate_tokens
-    size_bytes = messages.to_s.size
-    OllamaChat::TokenEstimator.estimate(size_bytes)
+    OllamaChat::TokenEstimator.estimate(messages.to_s)
   end
 
   # Counts the number of messages in the session's JSONL history.

data/lib/ollama_chat/database.rb

@@ -28,8 +28,10 @@ module OllamaChat::Database
     db_path = OC::XDG_STATE_HOME.join('settings.db').expand_path
 
     url = 'sqlite://' + db_path.to_path
-    OC::OLLAMA::CHAT::DATABASE_LOGFILE.dirname.mkpath
-    logger = Logger.new(OC::OLLAMA::CHAT::DATABASE_LOGFILE)
+    db_log = OC::OLLAMA::CHAT::LOG::DATABASE
+    db_log.dirname.mkpath
+    logger = Logger.new(db_log)
+    logger.level = Logger::WARN
     unless OllamaChat.const_defined?('DB')
       OllamaChat.const_set('DB', Sequel.connect(url, logger:))
     end

data/lib/ollama_chat/information.rb

@@ -133,11 +133,12 @@ module OllamaChat::Information
     end
     output.puts "🧠 Current chat model is #{bold{@model}}."
     context_usage = '%s of %s (%s)' % [
-      session.estimate_tokens.tokens_formatted,
+      messages.compacted_estimate_tokens.tokens_formatted,
       format_tokens(current_context_length),
-      bold { '%.1f%%' % (100 * context_filled)},
+      context_gauge(format('%.1f%%', 100 * context_filled)),
     ]
-    output.puts  "  Context Length: #{context_usage}"
+    output.puts  "  Context Usage: #{context_usage}"
+    output.puts  "  Conversation Length: #{conversation_length}"
     output.print '  '; think_mode.show(output:)
     output.print '  '; think_loud.show(output:)
     output.print '  '; think_strip.show(output:)
@@ -309,7 +310,8 @@ module OllamaChat::Information
   # @return [Hash{String => String}] a hash mapping collection names to their
   #   descriptions
   def collection_descriptions
-    cols = models::Collection.select(:name, :description).order(:name)
+    cols = models::Collection.where(enabled: true)
+      .select(:name, :description).order(:name)
     cols.each_with_object({}) do |c, hash|
       hash[c.name] = c.description
     end
@@ -344,6 +346,22 @@ module OllamaChat::Information
     prompt(:static_runtime_info).to_s % static_runtime_information_values
   end
 
+  # Returns a formatted string representing the estimated text length of
+  # the full stored conversation, excluding images and JSON scaffolding.
+  #
+  # Delegates to +MessageList#full_estimate_tokens+, which sums
+  # per-message +token_estimate+ (content + optional thinking) across
+  # all messages, respecting the +think_strip+ toggle. This differs from
+  # +Session#estimate_tokens+, which measures raw JSONL bytes including
+  # base64 images and metadata — the latter is the storage footprint,
+  # this is the model-facing text volume.
+  #
+  # @return [String] formatted as `"340.5 KT (1.2 MiB)"`
+  def conversation_length
+    es = messages.full_estimate_tokens
+    "%s (%s)" % [ es.tokens_formatted, es.bytes_formatted ]
+  end
+
   # The dynamic_runtime_information_values method compiles a set of
   # volatile runtime details that change frequently.
   #
@@ -367,6 +385,7 @@ module OllamaChat::Information
       voice:                voice.on? ? 'enabled' : 'disabled',
       weekday:              now.strftime('%A'),
       context_usage:        ,
+      conversation_length:  ,
     }
   end
 
@@ -402,7 +421,7 @@ module OllamaChat::Information
   #
   # @return [Float] the ratio of used context (e.g. `0.73` for 73%)
   def context_filled
-    es = session.estimate_tokens
+    es = messages.compacted_estimate_tokens
     (es.tokens.to_f / current_context_length).clamp(0..1).to_f
   end
 
@@ -417,10 +436,38 @@ module OllamaChat::Information
   def context_usage
     if cl = current_context_length
       '%s of %s (%s)' % [
-        session.estimate_tokens.tokens_formatted,
+        messages.compacted_estimate_tokens.tokens_formatted,
         format_tokens(current_context_length),
         '%.1f%%' % (100 * context_filled),
       ]
     end
   end
+  # Wraps a percentage string in an ANSI color based on context usage
+  # relative to compaction thresholds.
+  #
+  # Green:  below `keep_recent` budget — plenty of room.
+  # Yellow: between `keep_recent` and `reserve` — getting tight.
+  # Red:    above `reserve` — compaction imminent.
+  #
+  # Falls back to bold if context length is unknown.
+  #
+  # @param percent_string [String] the formatted percentage to colorize
+  # @return [String] the ANSI-colored percentage string
+  def context_gauge(percent_string)
+    tokens = messages.compacted_estimate_tokens.tokens
+    ctx    = current_context_length
+    return bold { percent_string } unless ctx
+
+    keep_recent = compact_ratio_tokens(:keep_recent, ctx)
+    reserve     = compact_ratio_tokens(:reserve, ctx)
+    bold do
+      if tokens < keep_recent
+        '🟢 ' + green { percent_string }
+      elsif tokens <= reserve
+        '🟡 ' + yellow { percent_string }
+      else
+        '🔴 ' + red { percent_string }
+      end
+    end
+  end
 end

data/lib/ollama_chat/logging.rb

@@ -8,8 +8,9 @@ module OllamaChat::Logging
   # @return [Logger] the active Logger instance
   def logger
     @logger ||= begin
-      OC::OLLAMA::CHAT::LOGFILE.dirname.mkpath
-      l = Logger.new(OC::OLLAMA::CHAT::LOGFILE)
+      path = OC::OLLAMA::CHAT::LOG::CHAT
+      path.dirname.mkpath
+      l = Logger.new(path)
       l.formatter = -> (severity, time, _progname, msg) do
         msg = msg.stringify_keys_recursive
         msg['level']    = severity

data/lib/ollama_chat/message.rb

@@ -16,6 +16,9 @@ module OllamaChat::MessageMixin
     if group_uuid = attributes[:group_uuid]
       self.group_uuid = group_uuid
     end
+    if tool_calls = attributes[:tool_calls]
+      self.tool_calls = tool_calls
+    end
   end
 
   # @!attribute content
@@ -40,6 +43,12 @@ module OllamaChat::MessageMixin
   #   @option setter [String] The UUIDv7 for the logical exchange.
   attr_accessor :group_uuid
 
+  # @!attribute tool_calls
+  #   @option getter [Array<Hash>, nil] structured tool-call entries for
+  #     programmatic access (e.g., on summary messages).
+  #   @option setter [Array<Hash>, nil] the tool-call entries.
+  attr_accessor :tool_calls
+
   # Ensures that the message has a `group_uuid` by generating a UUIDv7 if
   # missing. Returns self to allow for method chaining.
   #
@@ -57,6 +66,18 @@ module OllamaChat::MessageMixin
     Time.at((group_uuid.delete(?-)[0, 16].to_i(16) >> 16) / 1000.0) if group_uuid
   end
 
+  # Estimates the token count for this message's text content.
+  #
+  # @param strip_thinking [Boolean] if true, exclude the thinking content
+  #   from the byte count.
+  # @return [OllamaChat::TokenEstimator::Estimate] the estimated bytes and
+  #   tokens.
+  def token_estimate(strip_thinking: false)
+    bytes  = content.to_s.bytesize
+    bytes += thinking.to_s.bytesize unless strip_thinking
+    OllamaChat::TokenEstimator.estimate(bytes)
+  end
+
   # Returns true if the message is a tool message.
   #
   # @return [Boolean] true if the message has a present tool name, false
@@ -70,7 +91,7 @@ module OllamaChat::MessageMixin
   # @param a [Array] optional arguments for JSON conversion.
   # @return [Hash] a hash representation of the message.
   def as_json(*a)
-    { sender_name:, group_uuid: }.compact | super
+    { sender_name:, group_uuid:, tool_calls:, }.compact | super
   end
 end
 

data/lib/ollama_chat/message_format.rb

@@ -108,8 +108,7 @@ module OllamaChat::MessageFormat
   # @return [ String, nil ] the annotated string with a thinking emoji if
   #   enabled, otherwise nil
   def think_annotate(think_loud: chat.think_loud?, &block)
-    string = block.()
-    string.to_s.size == 0 and return
+    string = block.().full?(:to_s) or return
     if think_loud
       "💭\n#{string}\n"
     end