ollama_chat 0.0.121 → 0.0.122

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e457507428f39cb5f1641783d067f1424a1dca8908cc30e8331d05e141c68f2e
-  data.tar.gz: 9c14299158dec444c3debd7ba133678c04324a6985f26110ce779da37bdf295a
+  metadata.gz: d77fd2cddf7c921b77712a90d4d1d31b3daf0f80dc4170f71eb209e7ce46390b
+  data.tar.gz: af9f30997ca31d67d7ba1914a971b5abb165d1913b2723c0727f07929b4512e4
 SHA512:
-  metadata.gz: eafc7e3075b48d10dc9ad7ac1654cdb5af4e2c7b235cf2ff4e8ad4240518c77afc02167689c831987b25c9ac07d68f2a758d6d85d9bc4a1bad4537decc01ef26
-  data.tar.gz: 9492a500da2006ef57212e0f1a68444e35d94be81ad2a5abbd041daf73d9a3087af9873d36264182c77a7b76d3825697eaea45189dd69b227178df569c558c23
+  metadata.gz: ba243ffe79c5062b0feb5fc2d6389efff95216961567dbe9275f020cbdf811d1f04f238e95972d007e611109c3bcc795057c8a2c4afeeaf7d1b739301b91c0f5
+  data.tar.gz: badb4e4ccca4ee006cdb48fd66b107367c81d7bf3ee3717482e4c61f3bc4d6fcda80d4cc54edefb9a0b5af5a6dbcf32173eeb3e0f48f545d32f5c3508d472ba1

data/CHANGES.md

@@ -1,5 +1,122 @@
 # Changes
 
+## 2026-09-25 v0.0.122
+
+## Features
+
+*   **Per-model thinking-state support**: Added support for per-model thinking
+    states via the `/api/show` endpoint.
+    *   Replaced the `THINK_MODE_STATES` constant with a `think_mode_states`
+        method that reads `@model_metadata&.thinking&.full?(:values)` to return
+        a per-model subset, falling back to the full superset for
+        pre-**0.34.3** Ollama or non-thinking models.
+    *   Added `normalize_think_state` helper to canonicalize boolean
+        (`true`/`false`) and string (`"low"`/`"high"`/`"max"`) thinking values.
+    *   Added `:thinking` field to `ModelMetadata` data class.
+    *   Implemented think-mode clamping in `use_model` to disable thinking for
+        non-thinking models or clamp to the model's default when the current
+        level is unavailable.
+    *   Converted `DatabaseStateSelector` `states`/`off` to support `Proc` via
+        `ask_and_send_or_self(:call, @chat)`.
+    *   Converted `think_mode` and `voices` selectors in
+        `setup_state_selectors` to lambda-based `states:`.
+    *   Added `Thinking` display line to `info_model`.
+*   **Invidious YouTube captions**: Added `OllamaChat::Invidious` to fetch
+    video metadata and transcripts from an Invidious companion instance.
+    *   Uses `POST /companion/youtubei/v1/player` for `videoDetails` and
+        `captionTracks`.
+    *   Selects the best caption track by priority-ordered language regexes.
+    *   Fetches timedtext XML and extracts `<text>` elements via `Nokogiri`,
+        decoding double-encoded HTML entities.
+    *   Returns a formatted markdown header + transcript as a text IO.
+*   **Unified HTTP handling**: Added `HTTPHandling#request_url_response` to
+    consolidate `Excon.new` call sites, merging `http_options` (SSL, proxy)
+    with caller-supplied options.
+    *   Updated `ASR.transcribe`, `TTS.voices`, `TTS#fetch_tts`,
+        `GenerateImage#post_url`, `GenerateImage#get_url`, `GetURL#execute`,
+        `Invidious.fetch_video_info`, and `SourceFetching#fetch_source` to
+        route through this method.
+    *   Extracted audio/video MIME regex into `HAS_AUDIO` constant shared by
+        `parse_source` and the `get_url` tool.
+    *   Split `Fetcher` `middlewares` into class-level `self.middlewares` and
+        instance delegate; added `RedirectFollower` to the default stack.
+    *   Added `middlewares:` to streaming `excon` requests in `fetcher.rb`.
+*   **One-shot voice notification**: Added `OllamaChat::Speaker` concern
+    providing `speak(text, background:)` and `cancel_speaking`.
+    *   `OllamaChat::TTS` and `OllamaChat::Say` now include
+        `OllamaChat::Speaker`.
+    *   Added `Chat#speak` facade to resolve the configured voice handler.
+    *   `Dialog#readline_prompt` and `Dialog#confirm?` now speak the prompt
+        with a 10-second delay.
+    *   `Tools::PatchFile` announces "You can review the patch for the file …
+        now!" before opening `vimdiff`.
+    *   `AudioPlayer#start` redirects `ffplay` stdout/stderr to `/dev/null`.
+*   **ASR transcription pipeline**: Added `OllamaChat::ASR` client for
+    audio/video transcription.
+    *   Uploads audio/video as multipart form-data to the audio.cpp
+        `/v1/audio/transcriptions` endpoint.
+    *   Converts video sources to 16 kHz mono PCM WAV via a configurable
+        `ffmpeg` command (`CONVERT_COMMAND`).
+    *   Added `OC::OLLAMA::CHAT::ASR` config module with `URL`,
+        `CONVERT_COMMAND`, and `MODEL` settings.
+    *   Extended `/input` command with `-l <language>` option.
+    *   Routed `audio/*`, `video/*`, and specific `application/` MIME types
+        into `parse_audio`.
+    *   Added `Fetcher::ResponseMetadata.as_text(text)` factory for synthetic
+        `text/plain` IO responses.
+    *   Replaced hardcoded timeouts in `lib/ollama_chat/tts.rb` with values
+        from `config.timeouts`.
+*   **Audio/Video support in `get_url`**: Added `language` parameter to the
+    `get_url` tool definition for optional transcription hints.
+    *   Pre-transcribes `audio/*` and `video/*` sources via `chat.parse_audio`
+        before content-type dispatch.
+    *   Threads `language:` kwarg into `chat.import_source`.
+*   **Prompt management enhancements**:
+    *   Added `reset_prompt_count` and `choose_and_reset_count` to
+        `lib/ollama_chat/prompt_management.rb`.
+    *   Added `/prompt reset count` command.
+    *   Added `count:` keyword argument to `choose_prompt` to increment
+        `metadata['use_count']`.
+    *   Changed `all_prompts` sort to `use_count` descending, falling back to
+        name for tie-breaking.
+    *   Added `-i` summary instruction flag to `/input` command to prompt for
+        an optional instruction.
+    *   Added `instruction` parameter to `get_url` summarizing, threading it
+        through `summarize_source` and `summarize`.
+*   **Config-driven default persona**: Added `persona.default_name` to
+    `default_config.yml`.
+    *   Updated `initial_persona_name` in `personae_management.rb` to fall back
+        to `config.persona&.default_name`.
+
+## Improvements
+
+*   **CI and Dependencies**:
+    *   Added `ffmpeg` to the CI Docker image.
+    *   Added `nokogiri ~> 1.0` dependency.
+    *   Bumped `tins ~> 1.58`.
+    *   Added `require 'ollama_chat/utils/utf8_converter'` in
+        `png_metadata_extractor.rb`.
+    *   Reorganized `require` statements in `lib/ollama_chat/utils.rb`
+        alphabetically.
+*   **Error Handling**:
+    *   In `lib/ollama_chat/asr.rb`, capture the return value of `system` to
+        detect missing executables and print a clear "not found in PATH"
+        message.
+    *   Extract executable name via `Shellwords.split(cmd).first` for error
+        messages.
+*   **Documentation**:
+    *   Updated `ollama_chat` description in README to be more concise and
+        user-focused.
+    *   Updated YARD in `session.rb`, `state_selectors.rb`, and
+        `think_control.rb` to reference `Chat#think_mode_states`.
+
+## Bug Fixes
+
+*   **Pager Spec**: Changed `expect(Tins::Terminal).to receive(:lines)` to
+    `allow(Tins::Terminal).to receive(:lines)` in
+    `spec/ollama_chat/message_list_spec.rb` and removed the `skip 'no tty'`
+    guard.
+
 ## 2026-09-18 v0.0.121
 
 * Added `**_kwargs` splat to `Say.voices` to prevent `ArgumentError` when the

data/README.md

@@ -2,8 +2,8 @@
 
 ## Description
 
-**ollama_chat** is a chat client, that can be used to connect to an ollama
-server and enter chat conversations with the LLMs provided by it.
+**ollama_chat** is a terminal chat client that connects to an Ollama
+server and lets you converse with the LLMs it provides.
 
 ## Documentation
 

data/Rakefile

@@ -49,7 +49,7 @@ GemHadar do
   dependency             'reverse_markdown',      '~> 3.0'
   dependency             'kramdown-ansi',         '~> 0.5'
   dependency             'complex_config',        '~> 0.22', '>= 0.22.2'
-  dependency             'tins',                  '~> 1.57'
+  dependency             'tins',                  '~> 1.58'
   dependency             'search_ui',             '>= 0.2'
   dependency             'amatch',                '~> 0.4'
   dependency             'pdf-reader',            '~> 2.0'
@@ -61,6 +61,7 @@ GemHadar do
   dependency             'rubyzip',               '~> 3.0'
   dependency             'sequel',                '~> 5.0'
   dependency             'file-tail',             '~> 1.4'
+  dependency             'nokogiri',              '~> 1.0'
   development_dependency 'all_images',            '~> 0.12'
   development_dependency 'rspec',                 '~> 3.2'
   development_dependency 'kramdown',              '~> 2.0'

data/lib/ollama_chat/asr.rb

@@ -0,0 +1,110 @@
+require 'securerandom'
+
+# Standalone ASR (Speech-to-Text) transcription client for audio.cpp.
+#
+# Transcribes audio or video sources by uploading them as multipart
+# form-data to the audio.cpp `/v1/audio/transcriptions` endpoint.
+# Video sources are first converted to 16 kHz mono WAV via ffmpeg.
+#
+# @example Transcribing a WAV source
+#   text = OllamaChat::ASR.transcribe(source_io, chat:)
+#
+# @example Transcribing an MP4 video (ffmpeg extraction)
+#   text = OllamaChat::ASR.transcribe(source_io, chat:)
+module OllamaChat
+  class ASR
+    class << self
+      # Transcribes audio/video content via the audio.cpp ASR endpoint.
+      #
+      # @param source_io [IO] the audio/video source stream
+      #   (must respond to #content_type and be seekable)
+      # @param language [String, nil] optional language hint
+      #   (e.g. "en", "de") passed as the `language` form field
+      # @param chat [OllamaChat::Chat] the chat instance (for HTTP middleware)
+      #
+      # @return [String, nil] the transcribed text, or nil on failure
+      def transcribe(source_io, chat:, language: nil)
+        asr_url   = OC::OLLAMA::CHAT::ASR::URL
+        asr_model = OC::OLLAMA::CHAT::ASR::MODEL
+        input = Tempfile.new(['asr_in'])
+        wav   = Tempfile.new(['asr', '.wav'])
+        begin
+          IO.copy_stream(source_io, input)
+          input.flush
+
+          cmd = OC::OLLAMA::CHAT::ASR::CONVERT_COMMAND % {
+            input: input.path, output: wav.path
+          }
+          executable = Shellwords.split(cmd).first
+          result     = system(cmd, out: File::NULL, err: File::NULL)
+          if result.nil?
+            STDERR.puts "ASR: #{executable} not found in PATH."
+            return
+          end
+          unless File.size(wav.path) > 0
+            STDERR.puts "ASR: #{executable} produced no output."
+            return
+          end
+
+          url       = "#{asr_url}/v1/audio/transcriptions"
+          form_data = multipart_form_data(wav.path, model: asr_model, language:)
+          chat.request_url_response(:post, url, **form_data) do |response|
+            return JSON.parse(response.body)['text']
+          end
+        ensure
+          input.close!
+          wav&.close!
+        end
+      rescue JSON::ParserError, Excon::Error => e
+        if response = e.ask_and_send(:response)
+          status = response.status
+          result = JSON.parse(response.body) rescue nil
+        end
+        chat.log(:error, e, data: { status:, result: })
+        STDERR.puts "ASR transcription failed: #{e.message}"
+        nil
+      end
+
+      private
+
+      # Builds a multipart/form-data request body for the ASR endpoint.
+      #
+      # Constructs the wire format manually (boundary, text field parts,
+      # file part) so the result can be splatted directly into
+      # {HTTPHandling#request_url_response}.
+      #
+      # @param file_path [String] path to the WAV file to upload
+      # @param rest [Hash] additional form fields (e.g. `model:`,
+      #   `language:`); `nil` values are omitted via `compact`
+      #
+      # @return [Hash] Excon-compatible options with `:headers`
+      #   (Content-Type including the generated boundary), `:expects`
+      #   (200), and `:body` (the assembled multipart string)
+      def multipart_form_data(file_path, **rest)
+        path     = Pathname.new(file_path)
+        body     = ''
+        boundary = SecureRandom.hex(8)
+
+        rest.compact.each do |field_name, field_value|
+          body << "--#{boundary}\r\n"
+          body << "Content-Disposition: form-data; name=\"#{field_name}\"\r\n\r\n"
+          body << "#{field_value}\r\n"
+        end
+
+        body << "--#{boundary}" << Excon::CR_NL
+        body << %{Content-Disposition: form-data; name="file"; filename="#{path.basename}"} << Excon::CR_NL
+        body << 'Content-Type: audio/wav' << Excon::CR_NL
+        body << Excon::CR_NL
+        body << path.binread
+        body << Excon::CR_NL
+        body << "--#{boundary}--" << Excon::CR_NL
+
+        rest.symbolize_keys_recursive.compact | {
+          headers: { 'Content-Type' => %{multipart/form-data; boundary="#{boundary}"} },
+          expects: 200,
+          body:,
+        }
+      end
+    end
+  end
+end

data/lib/ollama_chat/chat.rb

@@ -162,15 +162,14 @@ class OllamaChat::Chat
   # @return [OllamaChat::RedisCache, nil] the cache instance
   attr_reader :cache
 
-
   # Returns the voice handler class based on the configuration.
   #
   # This method resolves the voice handler class specified in the config.
-  # If running within RSpec, it returns an empty array to avoid side effects.
+  # If running within RSpec, it returns nil to avoid side effects.
   #
-  # @return [Class, Array] the voice handler class or an empty array if in test mode
+  # @return [Class, NilClass] the voice handler class or nil if in test mode
   def voice_handler
-    defined?(RSpec) and return []
+    defined?(RSpec) and return nil
     case config.voice.handler
     when 'OllamaChat::TTS'
       OllamaChat::TTS
@@ -295,6 +294,30 @@ class OllamaChat::Chat
     content
   end
 
+  # Synthesizes and plays a short voice notification using the session's
+  # current voice.
+  #
+  # This is the chat-level facade for one-shot speech: it resolves the
+  # active voice, instantiates the configured voice handler, and delegates
+  # to its `#speak` method. It is a no-op when the voice switch is off,
+  # no voice is selected, or the handler lacks `#speak`.
+  #
+  # @param text [String] the text to speak
+  # @param background [Boolean, Integer] pass `true` for an immediate
+  #   background thread, `false` for inline, or a numeric delay in
+  #   seconds (e.g. `10`) to spawn a background thread that sleeps
+  #   before speaking
+  #
+  # @return [OllamaChat::TTS, OllamaChat::Say, nil] the voice handler
+  #   instance when a background thread was spawned (so callers can call
+  #   `cancel_speaking`), or `nil` for inline playback or when voice is off
+  def speak(text, background: true)
+    voice.on? or return
+    voice = session.current_voice.full? or return
+    voice_handler.method_defined?(:speak) or return
+    voice_handler.new(chat: self, voice:).speak(text, background:)
+  end
+
   # Returns a human-readable string representation of the Chat object,
   # including the class name and the base URL.
   #

data/lib/ollama_chat/commands.rb

@@ -433,27 +433,30 @@ module OllamaChat::Commands
 
   command(
     name: :prompt,
-    regexp: %r(^/prompt(?:\s+(edit|info|add|delete|list|duplicate|import|export|reset|rename|sync|-e))?(\s+(?:-[ef]|-c\s+(?:\w+|\?)))?(?:\s+([^-].*))?$),
-    complete: [ 'prompt', %w[ edit info add delete list duplicate import export reset rename sync ] ],
+    regexp: %r(^/prompt(?:\s+(edit|info|add|delete|list|duplicate|import|export|reset count|reset|rename|sync|-e))?(\s+(?:-[ef]|-c\s+(?:\w+|\?)))?(?:\s+([^-].*))?$),
+    complete: [ 'prompt', %w[ edit info add delete list duplicate import export reset\ count reset rename sync ] ],
     optional: true,
     options: '[-c CONTEXT|-e|-f]',
     help: <<~EOT,
       📝 Manage prompt templates:
           Subcommands: edit, info, add, delete, list,
-          duplicate, import, export, reset, rename,
-          sync.
+          duplicate, import, export, reset count, reset,
+          rename, sync.
          Options: -c [context]
                      (? for interactive in /prompt),
                   -e (edit next)
     EOT
   ) do |subcommand, opts, filename|
     opts = go_command('fc:', opts)
-    context = if subcommand.nil? || subcommand == '-e'
+    context = case subcommand
+              when nil, '-e'
                 if opts[?c] == ??
                   choose_prompt_context
                 else
                   opts[?c] || 'prompt'
                 end
+              when 'reset count'
+                'prompt'
               else
                 opts[?c] || choose_prompt_context
               end
@@ -481,6 +484,8 @@ module OllamaChat::Commands
       export_prompt(context:)
     when 'info'
       info_prompt(context:)
+    when 'reset count'
+      choose_and_reset_count(context:)
     when 'reset'
       if prompt = choose_prompt(
           default: true,
@@ -498,8 +503,9 @@ module OllamaChat::Commands
       prompt_sync(context:)
     when nil, '-e'
       if prompt = choose_prompt(
-          prompt: 'Which template shall guide the next response? %s',
-          context:
+          prompt:  'Which template shall guide the next response? %s',
+          context: ,
+          count:   true
         ).full?(&:to_s)
         if subcommand
           prompt = edit_text(prompt)
@@ -820,38 +826,43 @@ module OllamaChat::Commands
 
   command(
     name: :input,
-    regexp: %r(^/input(?:\s+(path|context|embedding|summary)(?:\s*(?=\z))?)?((?:\s+-(?:[aprem]|c\s*#{OllamaChat::COLLECTION_NAME_REGEXP.source}|w\s*\d+|t\s*[-\w\.]+(?:,[-\w\.]+)*))*)(?:\s+([^-].*))?$),
+    regexp: %r(^/input(?:\s+(path|context|embedding|summary)(?:\s*(?=\z))?)?((?:\s+-(?:[apreim]|c\s*#{OllamaChat::COLLECTION_NAME_REGEXP.source}|w\s*\d+|t\s*[-\w\.]+(?:,[-\w\.]+)*|l\s*[-\w]+))*)(?:\s+([^-].*))?$),
     optional: true,
     complete: [ 'input', %w[ path context embedding summary ] ],
     options: <<~EOT,
        [
-         -w|-a|-p|-e|-m|
+          -w|-a|-p|-e|-m|-i|
          -c <collection>|
-         -t <tags>
+         -t <tags>|
+         -l <language>
        ]
       [arg…]
     EOT
     help: <<~EOT
       📥 Import content (read, summarize, embed, context)
          Subcommands: path, context, embedding, summary
-          Options: -p (pattern), -w [words], -a (all),
-                   -c [collection], -t [tags], -e (edit),
-                   -m (monochrome, strip ANSI from file content)
+           Options: -p (pattern), -w [words], -a (all),
+                    -c [collection], -t [tags], -e (edit),
+                    -m (monochrome), -i (summary instruction),
+                    -l [language]
     EOT
   ) do |input_mode,opts,arg|
     disable_content_parsing
     case input_mode
     when 'summary'
-      opts = go_command('paw:', opts)
+      opts = go_command('paw:i', opts)
+      instruction = if opts[?i]
+        ask?(prompt: 'Summary instruction (Enter to skip): ').full?(:strip)
+      end
       if opts[?p]
         words = opts.fetch(?w, 100)
         all   = opts.fetch(?a, false)
         patterns = extract_patterns(arg)
-        next provide_file_set_content(patterns, all:, skip_blank: true) { summarize(_1, words:) } || :next
+        next provide_file_set_content(patterns, all:, skip_blank: true) { summarize(_1, words:, instruction:) } || :next
       elsif arg
         words = opts.fetch(?w, 100)
         source = arg
-        next summarize(source, words:) || :next
+        next summarize(source, words:, instruction:) || :next
       else
         STDERR.puts "Need a source to summarize for input!"
         next :next
@@ -915,17 +926,17 @@ module OllamaChat::Commands
         next :next
       end
     else
-      opts = go_command('paem', opts)
+      opts = go_command('paeml:', opts)
       if opts[?p]
         all = opts.fetch(?a, false)
         patterns = extract_patterns(arg)
         next provide_file_set_content(patterns, all:, skip_blank: true) do |src|
-          content = import(src)
+          content = import(src, language: opts[?l])
           opts[?m] ? OllamaChat::Utils::StripANSI.strip_ansi(content) : content
         end || :next
       elsif arg
         source = arg
-        content = import(source) or next :next
+        content = import(source, language: opts[?l]) or next :next
         content = OllamaChat::Utils::StripANSI.strip_ansi(content) if opts[?m]
         content = edit_text(content) if opts[?e]
         content

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

@@ -89,7 +89,7 @@ class OllamaChat::Database::Models::Session < Sequel::Model(OllamaChat::DB)
   #   @return [String, nil] A JSON-serialized string containing default settings for tools.
   #
   # @!attribute [v] think_mode
-  #   @return [String] The current thinking mode (must be one of `THINK_MODE_STATES`).
+  #   @return [String] The current thinking mode (must be one of `Chat#think_mode_states`).
   #
   # @!attribute [v] think_loud_enabled
   #   @return [Boolean] Whether thinking annotations are displayed in the output.

data/lib/ollama_chat/dialog.rb

@@ -19,10 +19,13 @@ module OllamaChat::Dialog
       old_pre_input_hook = Reline.pre_input_hook
       Reline.pre_input_hook = -> { Reline.insert_text prefill.to_s }
     end
+    speaker = speak(prompt, background: 10)
     Reline.readline(prompt, true)&.chomp
+
   rescue Interrupt
     return nil
   ensure
+    speaker&.cancel_speaking
     prefill and Reline.pre_input_hook = old_pre_input_hook
   end
 
@@ -46,6 +49,7 @@ module OllamaChat::Dialog
     if prompt.include?('%s')
       prompt = prompt % (timeout ? ('timeout in %us' % timeout) : 'no timeout')
     end
+    speaker = speak(prompt, background: 10) if timeout.nil?
     output.print prompt
     min    = 1
     time   = 0
@@ -86,6 +90,8 @@ module OllamaChat::Dialog
       end
       nil
     end
+  ensure
+    speaker&.cancel_speaking
   end
 
   private

data/lib/ollama_chat/http_handling.rb

@@ -72,4 +72,29 @@ module OllamaChat::HTTPHandling
       &block
     )
   end
+
+  # Performs an HTTP request with configuration-aware options.
+  #
+  # Merges the caller-supplied options (body, headers, etc.) with the
+  # HTTP options generated by `http_options` (SSL verification, proxy)
+  # and sends the request via Excon.
+  #
+  # @param method [Symbol] the HTTP method (`:get` or `:post`).
+  # @param url [String] the target URL.
+  # @param options [Hash] request options (e.g. `:body`, `:headers`).
+  # @yield [response] yields the Excon response object when a block is
+  #   given.
+  # @return [Excon::Response, Object] the response object, or the block's
+  #   return value if a block was provided.
+  def request_url_response(method, url, **options, &block)
+    normalized_url = OllamaChat::Utils::Fetcher.normalize_url(url)
+    options        = http_options(normalized_url) | options
+    excon          = Excon.new(url, options)
+    response       = excon.request(method:)
+    if block
+      block.(response)
+    else
+      response
+    end
+  end
 end

data/lib/ollama_chat/information.rb

@@ -97,8 +97,14 @@ module OllamaChat::Information
   #   (defaults to STDOUT).
   def info_model(output: STDOUT)
     output.puts "🧠 Current chat model is #{bold{@model}}."
-    output.puts   "  Capabilities: #{Array(@model_metadata&.capabilities) * ', '}"
     output.puts   "  Families: #{Array(@model_metadata&.families) * ', '}"
+    output.puts   "  Capabilities: #{Array(@model_metadata&.capabilities) * ', '}"
+    if @model_metadata&.thinking
+      thinking = @model_metadata.thinking
+      levels   = Array(thinking.values).map { normalize_think_state(_1) }
+      default  = normalize_think_state(thinking.default)
+      output.puts "  Thinking: #{levels * ', '} (default: #{bold{default}})"
+    end
 
     profiles = models::ModelOptions.where(model_name: @model).order(:profile).all
     if profiles.full?