ollama_chat 0.0.24 → 0.0.26

data/lib/ollama_chat/history.rb

@@ -1,29 +1,77 @@
+# A module that provides history management functionality for OllamaChat
+# sessions.
+#
+# The History module encapsulates methods for initializing, saving, and
+# clearing command-line history within the OllamaChat application. It handles
+# persistence of user input history to a file and ensures that chat sessions
+# can maintain state across invocations by loading previous command histories.
+#
+# @example Initializing chat history
+#   chat.init_chat_history
+#
+# @example Saving chat history
+#   chat.save_history
+#
+# @example Clearing chat history
+#   chat.clear_history
 module OllamaChat::History
-  # Returns the full path of the chat history filename based on the
-  # configuration.
+  # The chat_history_filename method constructs and returns the full file path
+  # for the chat history file.
+  #
+  # This method takes the configured chat history filename from the
+  # configuration and expands it to an absolute path using File.expand_path.
+  # This ensures that the returned path is fully qualified and can be used
+  # reliably for reading from or writing to the chat history file.
+  #
+  # @return [String] the absolute file path to the chat history file as
+  # specified in the configuration
   def chat_history_filename
     File.expand_path(config.chat_history_filename)
   end
 
-  # Initializes the chat history by loading it from a file if it exists, and
-  # then loads the history into Readline::HISTORY.
+  # The init_chat_history method initializes the chat session by loading
+  # previously saved command history from a file.
+  #
+  # This method checks for the existence of a chat history file and, if found,
+  # loads its contents into the Readline::HISTORY array. It clears the current
+  # history and replaces it with the saved history data. Any errors during the
+  # loading process are caught and logged as warnings, but do not interrupt the
+  # execution flow.
   def init_chat_history
     if File.exist?(chat_history_filename)
       File.open(chat_history_filename, ?r) do |history|
         history_data = JSON.load(history)
-        clear_history
+        Readline::HISTORY.clear
         Readline::HISTORY.push(*history_data)
       end
     end
+  rescue => e
+    warn "Caught #{e.class} while loading #{chat_history_filename.inspect}: #{e}"
   end
 
-  # Saves the current chat history to a file in JSON format.
+  # The save_history method persists the current command history to a file.
+  #
+  # This method serializes the Readline::HISTORY array into JSON format and
+  # writes it to the chat history filename. It handles potential errors during
+  # the write operation by catching exceptions and issuing a warning message.
   def save_history
     File.secure_write(chat_history_filename, JSON.dump(Readline::HISTORY))
+  rescue => e
+    warn "Caught #{e.class} while saving #{chat_history_filename.inspect}: #{e}"
   end
 
-  # Clears all entries from Readline::HISTORY.
+  # The clear_history method clears the Readline history array and ensures that
+  # the chat history is saved afterwards.
+  #
+  # This method removes all entries from the Readline::HISTORY array,
+  # effectively clearing the command history maintained by the readline
+  # library. It then calls save_history to persist this cleared state to the
+  # configured history file. The method uses an ensure block to guarantee that
+  # save_history is called even if an exception occurs during the clearing
+  # process.
   def clear_history
     Readline::HISTORY.clear
+  ensure
+    save_history
   end
 end

data/lib/ollama_chat/information.rb

@@ -1,3 +1,20 @@
+# A module that provides information and user agent functionality for
+# OllamaChat
+#
+# The Information module encapsulates methods for managing application
+# identification, displaying version and configuration details, and handling
+# command-line interface help messages. It includes user agent capabilities for
+# HTTP requests and provides comprehensive information display features for
+# chat sessions.
+#
+# @example Displaying application information
+#   chat.info
+#
+# @example Showing version details
+#   chat.version
+#
+# @example Displaying usage help
+#   chat.usage
 module OllamaChat::Information
   extend Tins::Concern
 
@@ -6,6 +23,20 @@ module OllamaChat::Information
     extend UserAgent
   end
 
+  # A module that provides user agent functionality for identifying the
+  # application.
+  #
+  # This module encapsulates methods for determining the application name and
+  # constructing a standardized user agent string that includes the application
+  # name and version. It is designed to be included in classes that need to
+  # provide identification information for HTTP requests or other
+  # communications.
+  #
+  # @example Accessing the program name
+  #   UserAgent.progname # => "ollama_chat"
+  #
+  # @example Generating a user agent string
+  #   UserAgent.user_agent # => "ollama_chat/0.0.25"
   module UserAgent
     # The progname method returns the name of the application.
     #
@@ -92,7 +123,7 @@ module OllamaChat::Information
       /stream                         toggle stream output
       /location                       toggle location submission
       /voice [change]                 toggle voice output or change the voice
-      /last                           show the last system/assistant message
+      /last [n]                       show the last n / 1 system/assistant message
       /list [n]                       list the last n / all conversation exchanges
       /clear [what]                   clear what=messages|links|history|tags|all
       /clobber                        clear the conversation, links, and collection

data/lib/ollama_chat/kramdown_ansi.rb

@@ -1,3 +1,15 @@
+# A module that provides Kramdown::ANSI styling configuration and parsing
+# functionality for OllamaChat.
+#
+# This module handles the setup and application of ANSI styles for markdown
+# rendering, allowing for customizable terminal output formatting. It manages
+# the configuration of ANSI styles either from environment variables or falls
+# back to default settings, and provides methods to parse content with the
+# configured styling.
+#
+# @example Configuring custom ANSI styles via environment variable
+#   Set KRAMDOWN_ANSI_OLLAMA_CHAT_STYLES to a JSON object containing style
+#   definitions for customizing markdown output formatting in the terminal.
 module OllamaChat::KramdownANSI
   # The configure_kramdown_ansi_styles method sets up ANSI styling for
   # Kramdown::ANSI output by checking for specific environment variables and
@@ -21,11 +33,13 @@ module OllamaChat::KramdownANSI
   # content with appropriate terminal formatting based on the application's
   # styling configuration.
   #
-  # @param content [ String ] the raw content to be parsed and formatted
+  # @param content [ String, nil ] the raw content to be parsed and formatted.
+  #   If nil, returns an empty string.
   #
   # @return [ String ] the content formatted with ANSI escape sequences
   # according to the configured styles
   def kramdown_ansi_parse(content)
+    content.nil? and return ''
     Kramdown::ANSI.parse(content, ansi_styles: @kramdown_ansi_styles)
   end
 end

data/lib/ollama_chat/message_format.rb

@@ -1,3 +1,19 @@
+# A module that provides formatting functionality for chat messages.
+#
+# The MessageFormat module encapsulates methods for determining message icons
+# based on whether images are present, and for conditionally annotating content
+# with thinking or talk indicators. It supports customizable formatting of
+# message text for display in terminal interfaces.
+#
+# @example Using message_type to determine icon based on images
+#   message_type([])        # => "📨"
+#   message_type(["image"]) # => "📸"
+#
+# @example Annotating content with thinking indicator
+#   think_annotate { "Thinking..." } # => "💭\nThinking...\n" (when think is enabled)
+#
+# @example Annotating content with talk indicator
+#   talk_annotate { "Speaking..." } # => "💬\nSpeaking...\n" (when think is enabled)
 module OllamaChat::MessageFormat
   # The message_type method determines the appropriate message icon based on
   # whether images are present.

data/lib/ollama_chat/message_list.rb

@@ -1,3 +1,33 @@
+# A collection class for managing chat messages with support for system
+# prompts, paged output, and conversation history.
+
+# This class provides functionality for storing, retrieving, and displaying
+# chat messages in a structured manner. It handles system prompts separately
+# from regular user and assistant messages, supports pagination for displaying
+# conversations, and offers methods for manipulating message history including
+# clearing, loading, saving, and dropping exchanges. The class integrates with
+# Kramdown::ANSI for formatted output and supports location information in
+# system messages.
+
+# @example Creating a new message list
+#   chat = OllamaChat::Chat.new
+#   messages = OllamaChat::MessageList.new(chat)
+#
+# @example Adding messages to the list
+#   messages << Ollama::Message.new(role: 'user', content: 'Hello')
+#   messages << Ollama::Message.new(role: 'assistant', content: 'Hi there!')
+#
+# @example Displaying conversation history
+#   messages.list_conversation(5)  # Shows last 5 exchanges
+#
+# @example Clearing messages
+#   messages.clear  # Removes all non-system messages
+#
+# @example Loading a saved conversation
+#   messages.load_conversation('conversation.json')
+#
+# @example Saving current conversation
+#   messages.save_conversation('my_conversation.json')
 class OllamaChat::MessageList
   include Term::ANSIColor
   include OllamaChat::MessageFormat
@@ -11,8 +41,20 @@ class OllamaChat::MessageList
     @messages = []
   end
 
+  # The system attribute reader returns the system prompt for the chat session.
+  #
+  # @attr_reader [ String, nil ] the current system prompt content or nil if not set
   attr_reader :system
 
+  # The messages attribute reader returns the messages set for this object,
+  # initializing it lazily if needed.
+  #
+  # The messages set is memoized, meaning it will only be created once per
+  # object instance and subsequent calls will return the same
+  # OllamaChat::MessageList instance.
+  #
+  # @attr_reader [OllamaChat::MessageList] A MessageList object containing all
+  # messages associated with this instance
   attr_reader :messages
 
   # Returns the number of messages stored in the message list.
@@ -111,11 +153,15 @@ class OllamaChat::MessageList
   # from the user. It uses a pager for output and returns the instance itself.
   #
   # @return [ OllamaChat::MessageList ] returns the instance of the class
-  def show_last
-    message = last
-    message&.role == 'user' and return
+  def show_last(n = nil)
+    n ||= 1
+    messages = @messages.reject { |message| message.role == 'user' }
+    n = n.clamp(0..messages.size)
+    n <= 0 and return
     use_pager do |output|
-      output.puts message_text_for(message)
+      messages[-n..-1].to_a.each do |message|
+        output.puts message_text_for(message)
+      end
     end
     self
   end
@@ -277,7 +323,8 @@ class OllamaChat::MessageList
   # If the output would exceed the terminal's line capacity, it pipes the content
   # through an appropriate pager command (like 'less' or 'more').
   #
-  # @param block [Proc] A block that yields an IO object to write output to
+  # @yield A block that yields an IO object to write output to
+  # @yieldparam [IO] the IO object to write to
   def use_pager
     command       = determine_pager_command
     output_buffer = StringIO.new

data/lib/ollama_chat/message_output.rb

@@ -1,3 +1,15 @@
+# A module that provides output functionality for chat messages.
+#
+# This module encapsulates methods for piping assistant responses to command
+# standard input and writing assistant responses to files. It handles the
+# mechanics of sending output to external processes or saving content to disk
+# while providing appropriate error handling and user feedback.
+#
+# @example Piping a response to a command
+#   chat.pipe('cat > output.txt')
+#
+# @example Writing a response to a file
+#   chat.output('response.txt')
 module OllamaChat::MessageOutput
   # The pipe method forwards the last assistant message to a command's standard
   # input.

data/lib/ollama_chat/model_handling.rb

@@ -1,3 +1,20 @@
+# A module that provides functionality for managing Ollama models, including
+# checking model availability, pulling models from remote servers, and handling
+# model presence verification.
+#
+# This module encapsulates the logic for interacting with Ollama models,
+# ensuring that required models are available locally before attempting to use
+# them in chat sessions. It handles both local model verification and remote
+# model retrieval when necessary.
+#
+# @example Checking if a model is present
+#   chat.model_present?('llama3.1')
+#
+# @example Pulling a model from a remote server
+#   chat.pull_model_from_remote('mistral')
+#
+# @example Ensuring a model is available locally
+#   chat.pull_model_unless_present('phi3', {})
 module OllamaChat::ModelHandling
   # The model_present? method checks if the specified Ollama model is available.
   #

data/lib/ollama_chat/ollama_chat_config/default_config.yml

@@ -21,8 +21,10 @@ prompts:
     %{words} words:
 
     %{source_content}
-  web: |
-    Answer the the query %{query} using these sources and summaries:
+  web_embed: |
+    Answer the the query %{query} using the provided chunks.
+  web_import: |
+    Answer the the query %{query} using these imported source:
 
     %{results}
   location: You are at %{location_name}, %{location_decimal_degrees}, on %{localtime}, preferring %{units}

data/lib/ollama_chat/ollama_chat_config.rb

@@ -1,12 +1,31 @@
 require 'pathname'
 
+# A configuration class for managing OllamaChat settings and file paths.
+#
+# This class handles the initialization and management of configuration files
+# for the OllamaChat application. It provides methods for setting up default
+# configurations, determining appropriate file paths for config and cache
+# directories, and managing the loading and creation of configuration files
+# based on XDG standards.
+#
+# @example Initializing with a custom configuration file
+#   config = OllamaChat::OllamaChatConfig.new('/path/to/custom/config.yml')
+#
+# @example Accessing default configuration paths
+#   config = OllamaChat::OllamaChatConfig.new
+#   config.default_config_path # => Path to the default configuration file
+#   config.config_dir_path     # => Path to the configuration directory
+#   config.cache_dir_path      # => Path to the cache directory
+#   config.database_path       # => Path to the documents database file
 class OllamaChat::OllamaChatConfig
   include ComplexConfig
   include FileUtils
 
+  # Path to the default config
   DEFAULT_CONFIG_PATH = Pathname.new(__FILE__).dirname.
     join('ollama_chat_config/default_config.yml')
 
+  # Content of the default config
   DEFAULT_CONFIG = File.read(DEFAULT_CONFIG_PATH)
 
   # The initialize method sets up the configuration file path and ensures the

data/lib/ollama_chat/parsing.rb

@@ -1,3 +1,16 @@
+# A module that provides content parsing functionality for OllamaChat.
+#
+# The Parsing module encapsulates methods for processing various types of input
+# sources including HTML, XML, CSV, RSS, Atom, PDF, and Postscript documents.
+# It handles content extraction and conversion into standardized text formats
+# suitable for chat interactions. The module supports different document
+# policies for handling imported or embedded content and provides utilities for
+# parsing structured data from multiple source types.
+#
+# @example Processing different document types
+#   chat.parse_source(html_io)    # Converts HTML to markdown
+#   chat.parse_source(pdf_io)     # Extracts text from PDF files
+#   chat.parse_source(csv_io)     # Formats CSV data into readable strings
 module OllamaChat::Parsing
   # The parse_source method processes different types of input sources and
   # converts them into a standardized text representation.

data/lib/ollama_chat/server_socket.rb

@@ -1,3 +1,25 @@
+# A module that provides server socket functionality for OllamaChat
+#
+# The ServerSocket module encapsulates the logic for creating and managing Unix
+# domain socket servers that enable external processes to send input to running
+# ollama_chat sessions. It supports both simple message transmission and
+# bidirectional communication with response handling, allowing for integration
+# with tools like ollama_chat_send.
+#
+# @example Sending a message to a running chat session
+#   OllamaChat::ServerSocket.send_to_server_socket(
+#     "Hello from external process",
+#     config: chat_config,
+#     type: :socket_input
+#   )
+#
+# @example Sending a message and waiting for a response
+#   response = OllamaChat::ServerSocket.send_to_server_socket(
+#     "What is the answer?",
+#     config: chat_config,
+#     type: :socket_input_with_response,
+#     parse: true
+#   )
 module OllamaChat::ServerSocket
   class << self
     # The send_to_server_socket method transmits a message to a Unix domain
@@ -13,12 +35,13 @@ module OllamaChat::ServerSocket
     # @param content [ String ] the message content to be sent
     # @param config [ ComplexConfig::Settings ] the configuration object containing server settings
     # @param type [ Symbol ] the type of message transmission, defaults to :socket_input
+    # @param runtime_dir [ String ] pathname to runtime_dir of socket file
     # @param parse [ TrueClass, FalseClass ] whether to parse the response, defaults to false
     #
     # @return [ UnixSocks::Message, nil ] the response from transmit_with_response if type
     # is :socket_input_with_response, otherwise nil
-    def send_to_server_socket(content, config:, type: :socket_input, parse: false)
-      server  = create_socket_server(config:)
+    def send_to_server_socket(content, config:, type: :socket_input, runtime_dir: nil, parse: false)
+      server  = create_socket_server(config:, runtime_dir:)
       message = { content:, type:, parse: }
       if type.to_sym == :socket_input_with_response
         server.transmit_with_response(message)
@@ -43,7 +66,10 @@ module OllamaChat::ServerSocket
     #
     # @return [UnixSocks::Server] a configured Unix domain socket server
     # instance ready to receive messages
-    def create_socket_server(config:)
+    def create_socket_server(config:, runtime_dir: nil)
+      if runtime_dir
+        return UnixSocks::Server.new(socket_name: 'ollama_chat.sock', runtime_dir:)
+      end
       if runtime_dir = config.server_socket_runtime_dir
         UnixSocks::Server.new(socket_name: 'ollama_chat.sock', runtime_dir:)
       else
@@ -52,6 +78,11 @@ module OllamaChat::ServerSocket
     end
   end
 
+  # The server_socket_message accessor method provides read and write access to
+  # the server socket message instance variable.
+  #
+  # @return [ Object, nil ] the current server socket message object or nil if
+  # not set
   attr_accessor :server_socket_message
 
   # Initializes the server socket to receive messages from the Ollama Chat

data/lib/ollama_chat/source_fetching.rb

@@ -1,3 +1,28 @@
+# A module that provides functionality for fetching and processing various
+# types of content sources.
+#
+# The SourceFetching module encapsulates methods for retrieving content from
+# different source types including URLs, file paths, and shell commands. It
+# handles the logic for determining the appropriate fetching method based on
+# the source identifier and processes the retrieved content through specialized
+# parsers depending on the content type. The module also manages image
+# handling, document importing, summarizing, and embedding operations while
+# providing error handling and debugging capabilities.
+#
+# @example Fetching content from a URL
+#   chat.fetch_source('https://example.com/document.html') do |source_io|
+#     # Process the fetched content
+#   end
+#
+# @example Importing a local file
+#   chat.fetch_source('/path/to/local/file.txt') do |source_io|
+#     # Process the imported file content
+#   end
+#
+# @example Executing a shell command
+#   chat.fetch_source('!ls -la') do |source_io|
+#     # Process the command output
+#   end
 module OllamaChat::SourceFetching
   # The http_options method prepares HTTP options for requests based on
   # configuration settings.
@@ -110,7 +135,6 @@ module OllamaChat::SourceFetching
     end
   end
 
-
   # Summarizes content from the given source IO and source identifier.
   #
   # This method takes an IO object containing document content and generates a
@@ -146,7 +170,6 @@ module OllamaChat::SourceFetching
     end
   end
 
-
   # Embeds content from the given source IO and source identifier.
   #
   # This method processes document content by splitting it into chunks using

data/lib/ollama_chat/switches.rb

@@ -1,4 +1,28 @@
+# A module that provides switch functionality for configuring application
+# behavior.
+#
+# The Switches module encapsulates various toggle switches used throughout the
+# OllamaChat application to control different features and settings such as
+# streaming, thinking, markdown output, voice output, embedding, and location
+# information. These switches allow users to dynamically enable or disable
+# specific functionalities during a chat session.
+#
+# @example Toggling a switch on/off
+#   switch = OllamaChat::Switches::Switch.new(value: false, msg: { true => 'Enabled', false => 'Disabled' })
+#   switch.toggle  # Turns the switch on
+#   switch.toggle  # Turns the switch off
 module OllamaChat::Switches
+  # A module that provides switch state checking functionality.
+  #
+  # The CheckSwitch module adds methods for checking the boolean state of
+  # switches and displaying their current status. It's designed to be included
+  # in switch classes to provide consistent behavior for querying switch states
+  # and outputting status messages.
+  #
+  # @example Checking switch states
+  #   switch = OllamaChat::Switches::Switch.new(value: true, msg: { true => 'On', false => 'Off' })
+  #   switch.on?   # Returns true
+  #   switch.off?  # Returns false
   module CheckSwitch
     extend Tins::Concern
 
@@ -23,6 +47,19 @@ module OllamaChat::Switches
     end
   end
 
+  # A switch class that manages boolean state with toggle and set
+  # functionality.
+  #
+  # The Switch class provides a simple way to manage boolean configuration
+  # options with methods to toggle, set, and query the current state. It
+  # includes messaging capabilities to provide feedback when the state changes.
+  #
+  # @example Creating and using a switch
+  #   switch = Switch.new(value: false, msg: { true => 'Enabled', false => 'Disabled' })
+  #   switch.toggle  # Turns the switch on
+  #   switch.value   # Returns true
+  #   switch.off?    # Returns false
+  #   switch.on?     # Returns true
   class Switch
     # The initialize method sets up the switch with a default value and
     # message.
@@ -64,6 +101,18 @@ module OllamaChat::Switches
     include CheckSwitch
   end
 
+  # A switch class that manages a boolean state based on a proc value.
+  #
+  # The CombinedSwitch class provides a way to manage a boolean configuration
+  # option where the state is determined by evaluating a stored proc. This is
+  # useful for complex conditions that depend on multiple factors or dynamic
+  # values, such as combining multiple switch states into a single effective
+  # state.
+  #
+  # @example Checking if embedding is currently performed
+  #   # When embedding_enabled is true and embedding_paused is false,
+  #   # the combined switch will return true
+  #   combined_switch.value # => true
   class CombinedSwitch
     # The initialize method sets up the switch with a value and message.
     #

data/lib/ollama_chat/utils/cache_fetcher.rb

@@ -1,5 +1,20 @@
 require 'digest/md5'
 
+# A cache fetcher implementation that handles caching of HTTP responses with
+# content type metadata.
+#
+# This class provides a mechanism to store and retrieve cached HTTP responses,
+# including their content types, using a key-based system. It is designed to
+# work with various cache backends and ensures that both the response body and
+# metadata are properly cached and retrieved for efficient subsequent requests.
+#
+# @example Using the CacheFetcher to cache and retrieve HTTP responses
+#   cache = Redis.new
+#   fetcher = OllamaChat::Utils::CacheFetcher.new(cache)
+#   fetcher.put('https://example.com', io)
+#   fetcher.get('https://example.com') do |cached_io|
+#     # Process cached content
+#   end
 class OllamaChat::Utils::CacheFetcher
   # The initialize method sets up the cache instance variable for the object.
   #

data/lib/ollama_chat/utils/chooser.rb

@@ -2,6 +2,22 @@ require 'amatch'
 require 'search_ui'
 require 'term/ansicolor'
 
+# A module that provides interactive selection functionality using fuzzy
+# matching and search capabilities.
+#
+# The Chooser module enables users to interactively select items from a list
+# using a search interface with fuzzy matching. It leverages the Amatch library
+# for similarity matching and SearchUI for the interactive display and
+# selection experience.
+#
+# @example Using the chooser in an interactive menu
+#   entries = ['apple', 'banana', 'cherry']
+#   selected = OllamaChat::Utils::Chooser.choose(entries, prompt: 'Choose a fruit:')
+#
+# @example Returning immediately if only one entry exists
+#   entries = ['single_option']
+#   result = OllamaChat::Utils::Chooser.choose(entries, return_immediately: true)
+#   # Returns 'single_option' directly without user interaction
 module OllamaChat::Utils::Chooser
   class << self
     include SearchUI

data/lib/ollama_chat/utils/fetcher.rb

@@ -5,7 +5,34 @@ require 'mime-types'
 require 'stringio'
 require 'ollama_chat/utils/cache_fetcher'
 
+# A fetcher implementation that handles retrieval and caching of HTTP
+# resources.
+#
+# This class provides functionality to fetch content from URLs, with support
+# for caching responses and their metadata. It handles various content types
+# and integrates with different cache backends to improve performance by
+# avoiding redundant network requests.
+#
+# @example Fetching content from a URL with caching
+#   fetcher = OllamaChat::Utils::Fetcher.new(cache: redis_cache)
+#   fetcher.get('https://example.com/data.json') do |tmp|
+#     # Process the fetched content
+#   end
 class OllamaChat::Utils::Fetcher
+  # A module that extends IO objects with content type metadata and expiration
+  # tracking.
+  #
+  # This module provides a way to attach MIME content type information and
+  # cache expiration details to IO objects, enabling them to carry metadata
+  # about their source and caching behavior. It is primarily used by fetcher
+  # implementations to decorate response objects with additional context for
+  # processing and caching decisions.
+  #
+  # @example Extending an IO object with header metadata
+  #   io = StringIO.new("content")
+  #   io.extend(OllamaChat::Utils::Fetcher::HeaderExtension)
+  #   io.content_type = MIME::Types['text/plain'].first
+  #   io.ex = 3600
   module HeaderExtension
     # The content_type method accesses the content type attribute of the object.
     #
@@ -30,6 +57,18 @@ class OllamaChat::Utils::Fetcher
     end
   end
 
+  # A custom error class raised when retrying HTTP requests without streaming.
+  #
+  # This exception is specifically used in the Fetcher class to indicate that
+  # an HTTP request should be retried using a non-streaming approach when a
+  # streaming attempt fails or is not supported.
+  #
+  # @example Handling the RetryWithoutStreaming error
+  #   begin
+  #     fetcher.get('https://example.com')
+  #   rescue RetryWithoutStreaming
+  #     # Handle retry with non-streaming method
+  #   end
   class RetryWithoutStreaming < StandardError; end
 
   # The get method retrieves content from a URL, using caching when available.
@@ -51,8 +90,9 @@ class OllamaChat::Utils::Fetcher
   def self.get(url, headers: {}, **options, &block)
     cache = options.delete(:cache) and
       cache = OllamaChat::Utils::CacheFetcher.new(cache)
+    cache and infobar.puts "Getting #{url.to_s.inspect} via cache…"
     if result = cache&.get(url, &block)
-      infobar.puts "Getting #{url.to_s.inspect} from cache."
+      infobar.puts "…hit, found#{result.content_type} content in cache."
       return result
     else
       new(**options).send(:get, url, headers:) do |tmp|