openclacky 1.5.20 → 1.5.21

data/lib/clacky/tools/web_search.rb

@@ -6,6 +6,7 @@ require "uri"
 require "cgi"
 require "base64"
 require_relative "../utils/encoding"
+require_relative "../deepseek_web_tools"
 
 module Clacky
   module Tools
@@ -37,7 +38,9 @@ module Clacky
       SEARCHER_TIMEOUT = 30
       PARALLEL_ENDPOINT = "https://search.parallel.ai/mcp"
       PARALLEL_SNIPPET_MAX_CHARS = 400
-      PROVIDER_COOLDOWN_SECONDS = 600
+      # Shared by every provider, hosted or free: one failure keeps that
+      # provider out of the retry path for the whole window.
+      PROVIDER_COOLDOWN_SECONDS = 3600
 
       def execute(query:, max_results: 10, working_dir: nil)
         if query.nil? || query.strip.empty?
@@ -62,10 +65,13 @@ module Clacky
             }
           rescue StandardError => e
             # Avoid paying the same network/handshake failure on every search.
-            if provider == :parallel
+            case provider
+            when :deepseek
+              Clacky::DeepSeekWebTools.mark_unavailable!
+            when :parallel
               reset_parallel_client
               @parallel_unavailable_until = Time.now + PROVIDER_COOLDOWN_SECONDS
-            elsif provider == :duckduckgo
+            when :duckduckgo
               @ddg_unavailable_until = Time.now + PROVIDER_COOLDOWN_SECONDS
             end
             last_error = e
@@ -90,6 +96,10 @@ module Clacky
           "Configured search provider '#{name}' failed. #{reason} " \
             "Check the key and the script at #{Clacky::SearchConfig.script_path}, " \
             "or reconfigure it in Settings → Search."
+        elsif providers.include?(:deepseek)
+          "DeepSeek web search failed and no free engine returned results. #{reason} " \
+            "Check the API key and balance in Settings → Web Search; DeepSeek will be " \
+            "retried in #{PROVIDER_COOLDOWN_SECONDS / 60} minutes."
         else
           "All search providers failed. #{reason}"
         end
@@ -102,13 +112,23 @@ module Clacky
         # broken key or script look like a low-quality result set.
         return [:custom] if Clacky::SearchConfig.script_path
 
-        PROVIDERS.reject do |provider|
+        free_chain = PROVIDERS.reject do |provider|
           unavailable_until = case provider
                               when :parallel then @parallel_unavailable_until
                               when :duckduckgo then @ddg_unavailable_until
                               end
           unavailable_until && Time.now < unavailable_until
         end
+
+        return free_chain unless Clacky::SearchConfig.deepseek_web?
+
+        # DeepSeek leads the chain but does not replace the free engines: a
+        # missing key, an exhausted balance or an outage should degrade to a
+        # working search rather than return nothing.
+        return free_chain if Clacky::DeepSeekWebTools.cooling_down?
+        return free_chain unless deepseek_web_available?
+
+        [:deepseek] + free_chain
       end
 
       # ── Parallel Free MCP ──────────────────────────────────────────────────
@@ -171,6 +191,27 @@ module Clacky
         end.join("\n")
       end
 
+      # ── DeepSeek hosted search (paid, opt-in) ──────────────────────────────
+
+      private def deepseek_web_available?
+        return false unless agent
+
+        agent.config.deepseek_web_ready?
+      rescue StandardError
+        false
+      end
+
+      private def search_deepseek(query, max_results)
+        config = agent.config
+        key = config.deepseek_web_key
+        Clacky::DeepSeekWebTools.search(
+          query: query,
+          count: max_results,
+          api_key: key,
+          base_url: config.deepseek_web_base_url(key)
+        )
+      end
+
       # ── Configured searcher (~/.clacky/searchers/<provider>.rb) ────────────
 
       private def search_custom(query, max_results)

data/lib/clacky/ui2/ui_controller.rb

@@ -1396,7 +1396,7 @@ module Clacky
       #   * the countdown reaches zero with no interaction -> returns :timeout
       # @param seconds [Integer] Countdown duration
       # @return [String, Symbol] feedback text, or :timeout
-      def request_feedback_with_countdown(seconds: 10)
+      def request_feedback_with_countdown(seconds: 20)
         theme = ThemeManager.current_theme
 
         queue = Queue.new

data/lib/clacky/ui_interface.rb

@@ -145,9 +145,10 @@ module Clacky
     # Auto-approve countdown for ask_user. Shows a live countdown
     # and lets the user press a key to take over and answer. Returns :timeout
     # when no one intervenes (agent should auto-decide and continue), or a
-    # feedback string / "" when the user steps in. Non-interactive UIs (web,
-    # json, channel) have no human watching a TTY, so they default to :timeout.
-    def request_feedback_with_countdown(seconds: 10)
+    # feedback string / "" when the user steps in, or :answered when Web has
+    # queued a full answer for steering. Non-interactive UIs (json, channel)
+    # default to :timeout.
+    def request_feedback_with_countdown(seconds: 20)
       :timeout
     end
 

data/lib/clacky/utils/file_processor.rb

@@ -226,6 +226,57 @@ module Clacky
       MIME_TYPES[File.extname(path).downcase] || "application/octet-stream"
     end
 
+    # Quantize with a frequency-weighted median-cut palette using only chunky_png.
+    # Keep the input on failure so the caller retains its existing size handling.
+    def self.quantize_png_base64(b64)
+      require "base64"
+      require "chunky_png"
+
+      image = ChunkyPNG::Image.from_blob(Base64.strict_decode64(b64))
+      counts = Hash.new(0)
+      image.pixels.each { |color| counts[color] += 1 }
+      if counts.size > 256
+        # Cache each box's widest RGBA channel; split until at most 256 remain.
+        make_box = lambda do |colors|
+          ranges = [24, 16, 8, 0].map do |shift|
+            values = colors.map { |color| (color >> shift) & 255 }
+            values.max - values.min
+          end
+          channel = ranges.each_index.max_by { |i| ranges[i] }
+          [colors, [24, 16, 8, 0][channel], ranges[channel]]
+        end
+        boxes = [make_box.call(counts.keys)]
+        while boxes.size < 256
+          index = boxes.each_index.max_by { |i| boxes[i][2] }
+          colors, shift, range = boxes.delete_at(index)
+          break if range.zero?
+
+          colors.sort_by! { |color| (color >> shift) & 255 }
+          halfway = colors.sum { |color| counts[color] } / 2.0
+          total = 0
+          split = colors.index { |color| (total += counts[color]) >= halfway } + 1
+          split = [split, colors.size - 1].min
+          boxes << make_box.call(colors.take(split))
+          boxes << make_box.call(colors.drop(split))
+        end
+
+        mapping = {}
+        boxes.each do |colors, _shift, _range|
+          weight = colors.sum { |color| counts[color] }
+          channels = [24, 16, 8, 0].map do |shift|
+            (colors.sum { |color| ((color >> shift) & 255) * counts[color] }.to_f / weight).round
+          end
+          representative = ChunkyPNG::Color.rgba(*channels)
+          colors.each { |color| mapping[color] = representative }
+        end
+        image.pixels.map! { |color| mapping.fetch(color) }
+      end
+      Base64.strict_encode64(image.to_blob(color_mode: ChunkyPNG::COLOR_INDEXED))
+    rescue StandardError => e
+      Clacky::Logger.debug("image_quantization_skipped", format: "png", reason: e.message)
+      b64
+    end
+
     # Downscale a base64-encoded image so its width is at most max_width pixels.
     #
     # Strategy:

data/lib/clacky/utils/model_pricing.rb

@@ -441,6 +441,91 @@ module Clacky
         }
       },
 
+      # GPT-6.1 Sol served through the openclacky gateway (oc- prefix, TokHub
+      # gpt group) — the same model as abs-gpt-6.1-sol, which is served by
+      # Bedrock; the two aliases exist because the lanes are priced differently.
+      # OpenAI's own card, tiered at 272K prompt tokens (the model's breakpoint,
+      # not the global 200K): above it every bucket doubles.
+      "oc-gpt-6.1-sol" => {
+        input: {
+          default: 2.00,                   # $2.00/MTok
+          over_272k: 4.00                  # $4.00/MTok
+        },
+        output: {
+          default: 10.00,                  # $10.00/MTok
+          over_272k: 20.00                 # $20.00/MTok
+        },
+        cache: {
+          write_default: 2.50,             # $2.50/MTok cache write
+          write_over_272k: 5.00,
+          read_default: 0.10,              # $0.10/MTok cache hit
+          read_over_272k: 0.20
+        },
+        tier_threshold: 272_000
+      },
+
+      # GPT-6 Astra served through the openclacky gateway (oc- prefix, same
+      # ciyuan gpt group as oc-gpt-6.1-sol, hence the same 272K breakpoint and
+      # the same series discount). Its card is much higher than Sol's.
+      "oc-gpt-6-astra" => {
+        input: {
+          default: 10.00,                  # $10.00/MTok
+          over_272k: 20.00                 # $20.00/MTok
+        },
+        output: {
+          default: 50.00,                  # $50.00/MTok
+          over_272k: 75.00                 # $75.00/MTok
+        },
+        cache: {
+          write_default: 12.50,            # $12.50/MTok cache write
+          write_over_272k: 25.00,
+          read_default: 1.00,              # $1.00/MTok cache hit
+          read_over_272k: 2.00
+        },
+        tier_threshold: 272_000
+      },
+
+      # GPT-6 Sol rides the same ciyuan gpt group and 272K breakpoint, and opens
+      # at the same $2 / $10 as 6.1 Sol, but its long-context card is its own:
+      # output goes to $15 (1.5x, not 2x) while cache reads jump 4x to $0.40.
+      "oc-gpt-6-sol" => {
+        input: {
+          default: 2.00,                   # $2.00/MTok
+          over_272k: 4.00                  # $4.00/MTok
+        },
+        output: {
+          default: 10.00,                  # $10.00/MTok
+          over_272k: 15.00                 # $15.00/MTok
+        },
+        cache: {
+          write_default: 2.50,             # $2.50/MTok cache write
+          write_over_272k: 5.00,
+          read_default: 0.10,              # $0.10/MTok cache hit
+          read_over_272k: 0.40
+        },
+        tier_threshold: 272_000
+      },
+
+      # GPT-6 Luna rides the same ciyuan gpt group and 272K breakpoint as
+      # Sol/Astra, but sits at the cheap end: $0.10 in / $0.50 out.
+      "oc-gpt-6-luna" => {
+        input: {
+          default: 0.10,                   # $0.10/MTok
+          over_272k: 0.20                  # $0.20/MTok
+        },
+        output: {
+          default: 0.50,                   # $0.50/MTok
+          over_272k: 0.75                  # $0.75/MTok
+        },
+        cache: {
+          write_default: 0.125,            # $0.125/MTok cache write
+          write_over_272k: 0.25,
+          read_default: 0.01,              # $0.01/MTok cache hit
+          read_over_272k: 0.02
+        },
+        tier_threshold: 272_000
+      },
+
       # Grok 4.7 served through the openclacky gateway (oc- prefix, TokHub
       # upstream). Official xAI list price; the long-context surcharge xAI
       # applies above 200K prompt tokens is not passed through, so both tiers
@@ -970,6 +1055,7 @@ module Clacky
       # rest of this file; normalize_model_name() lowercases incoming model
       # names before lookup.
 
+      # M2.x is retired on MiniMax's own API but still served via OpenRouter/Ollama — keep these rows.
       # M2.5 — high-throughput text model, optimised for coding and agent tasks
       # (40,960-token context window). Listed at Pay-as-You-Go prices.
       # Source: https://www.minimax.io/models/text (MiniMax-M2.5 product page).
@@ -979,19 +1065,25 @@ module Clacky
         cache:  { write: 0.30, read: 0.03 }
       },
 
-      # M3 (released 2026-06-01) is MiniMax's multimodal flagship (image +
-      # video input, 1,000,000-token context window). Official pricing is
-      # tiered by context length (≤512K vs 512K–1M); per the project's
-      # "displayed ≤ actual" convention we record only the lowest (≤512K)
-      # tier as a flat rate — the global TIERED_PRICING_THRESHOLD is 200K,
-      # so applying the 512K–1M rate to the 200K–512K band would over-charge.
-      # Listed at original (non-promotional) prices: input $0.60, output
-      # $2.40, cache read $0.12 per 1M tokens; cache write is billed at the
-      # input miss rate.
+      # M3.1-Flash (released 2026-10-19) — flat pricing, 1M context. Source:
+      # https://www.minimax.io/blog/minimax-m31f. No cache-write price is
+      # published; billed at the input rate per this table's convention.
+      "minimax-m3.1-flash" => {
+        input:  { default: 0.15, over_200k: 0.15 },
+        output: { default: 0.60, over_200k: 0.60 },
+        cache:  { write: 0.15, read: 0.015 }
+      },
+
+      # M3 — tiered at 512K input tokens; cache write billed at the input rate.
+      # Source: https://platform.minimax.io/docs/guides/pricing-paygo (Standard).
       "minimax-m3" => {
-        input:  { default: 0.60, over_200k: 0.60 },
-        output: { default: 2.40, over_200k: 2.40 },
-        cache:  { write: 0.60, read: 0.12 }
+        input:  { default: 0.30, over_512k: 0.60 },
+        output: { default: 1.20, over_512k: 2.40 },
+        cache:  {
+          write_default: 0.30, write_over_512k: 0.60,
+          read_default:  0.06, read_over_512k:  0.12
+        },
+        tier_threshold: 512_000
       },
 
       # M2.7 — text-only model (204,800-token context window). Listed at
@@ -1126,9 +1218,20 @@ module Clacky
       { match: /\Aoc-glm-/,          rate: 0.95, reason: "channel" }, # GLM via ciyuan glm - 5% off
       { match: /\Aoc-kimi-/,         rate: 0.9,  reason: "channel" }, # Kimi K3 via ciyuan - 10% off
       { match: /\Aoc-grok-/,         rate: 0.3,  reason: "channel" }, # Grok 4.7 via ciyuan grok - 70% off
+      { match: /\Aoc-gpt-/,          rate: 0.3,  reason: "channel" }, # GPT-6.1 Sol via ciyuan gpt - 70% off
       { match: /\Aor-(gemini|veo)-/, rate: 0.8,  reason: "promo" }    # Vertex Gemini/Veo launch promo - 20% off
     ].freeze
 
+    # Lanes sold above the rates in PRICING_TABLE. Bedrock GPT is the only
+    # one: it bills at OpenAI list (Global CRIS carries no premium), so its
+    # 20% is a pricing decision on top of the standard 5% processing fee -
+    # mirrored by bedrockOpenAIMarkup in llm_proxy. BYOK callers hit Bedrock
+    # under their own account and keep the list price, so only the "abs-"
+    # alias matches.
+    MARKUP_RULES = [
+      { match: /\Aabs-gpt-/, rate: 1.2 }
+    ].freeze
+
     class << self
       # Matching promotion for a model alias, or nil when none applies.
       #   rate   - multiplier applied to the list price
@@ -1149,6 +1252,20 @@ module Clacky
         info ? info[:rate] : 1.0
       end
 
+      # Multiplier applied to the list price by the lane serving this alias.
+      def markup_rate(model)
+        name = model.to_s.downcase
+        return 1.0 if name.empty?
+
+        rule = MARKUP_RULES.find { |r| r[:match].match?(name) }
+        rule ? rule[:rate] : 1.0
+      end
+
+      # What a token actually costs us: promotion and lane markup combined.
+      def effective_rate(model)
+        discount_rate(model) * markup_rate(model)
+      end
+
       # Calculate cost for the given model and usage
       #
       # @param model [String] Model identifier
@@ -1213,7 +1330,7 @@ module Clacky
         # Promotions are keyed on the requested alias, so apply them last: the
         # table above holds list prices shared with BYOK callers.
         {
-          cost: (input_cost + output_cost + cache_cost) * discount_rate(model),
+          cost: (input_cost + output_cost + cache_cost) * effective_rate(model),
           source: source
         }
       end
@@ -1378,6 +1495,8 @@ module Clacky
           "glm-4.7"
         # MiniMax — model ids in providers.rb use capitalised "MiniMax-M*"
         # but we match case-insensitively and map to the lowercased table key.
+        when /^minimax-m3[.]1-flash$/i
+          "minimax-m3.1-flash"
         when /^minimax-m3$/i
           "minimax-m3"
         when /^minimax-m2\.7$/i

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.5.20"
+  VERSION = "1.5.21"
 end