openclacky 1.2.12 → 1.2.14

data/lib/clacky/tools/web_search.rb

@@ -120,17 +120,67 @@ module Clacky
 
       # ── Bing ───────────────────────────────────────────────────────────────
 
+      BING_ENDPOINTS = [
+        ["cn.bing.com", "zh-CN,zh;q=0.9,en;q=0.8"],
+        ["www.bing.com", "en-US,en;q=0.9"]
+      ].freeze
+
+      # Race both Bing endpoints in parallel and return the first relevant result.
+      # cn.bing.com works best from mainland China; www.bing.com works best from
+      # overseas. Racing avoids guessing the network egress and recovers from
+      # one endpoint temporarily returning anti-scrape filler. If both return
+      # irrelevant garbage, fall back to whichever came back non-empty.
       private def search_bing(query, max_results)
-        encoded_query = CGI.escape(query)
-        # cn.bing.com redirects to www.bing.com for non-China IPs (e.g. GitHub CI);
-        # follow_redirects ensures both environments work with the same code path.
-        url = URI("https://cn.bing.com/search?q=#{encoded_query}&count=#{max_results}")
-        response = http_get(url, accept_language: "zh-CN,zh;q=0.9,en;q=0.8", follow_redirects: 2)
+        queue = Queue.new
+        threads = BING_ENDPOINTS.map do |host, lang|
+          Thread.new do
+            results = bing_fetch(host, lang, query, max_results)
+            queue.push([host, results])
+          rescue StandardError
+            queue.push([host, []])
+          end
+        end
+
+        winner = nil
+        runner_up = nil
+        BING_ENDPOINTS.length.times do
+          _host, results = queue.pop
+          if bing_results_relevant?(results, query)
+            winner = results
+            break
+          elsif !results.empty? && runner_up.nil?
+            runner_up = results
+          end
+        end
+
+        threads.each(&:kill)
+        winner || runner_up || []
+      end
+
+      private def bing_fetch(host, lang, query, max_results)
+        url = URI("https://#{host}/search?q=#{CGI.escape(query)}&count=#{max_results}&form=QBLH")
+        response = http_get(url, accept_language: lang, follow_redirects: 2,
+                                 referer: "https://#{host}/")
         return [] unless response.is_a?(Net::HTTPSuccess)
 
         parse_bing_html(response.body, max_results)
       end
 
+      # A real Bing answer mentions at least one query token in the titles or
+      # snippets. The anti-scrape fallback returns top-domain filler (Yandex,
+      # Bunnings, WikiLeaks, …) that shares nothing with the query.
+      private def bing_results_relevant?(results, query)
+        return false if results.empty?
+
+        tokens = query.downcase.scan(/[\p{L}\p{N}]+/).reject { |t| t.length < 2 }
+        return true if tokens.empty?
+
+        results.any? do |r|
+          haystack = "#{r[:title]} #{r[:snippet]}".downcase
+          tokens.any? { |t| haystack.include?(t) }
+        end
+      end
+
       private def parse_bing_html(html, max_results)
         results = []
         html = Clacky::Utils::Encoding.to_utf8(html)
@@ -199,7 +249,7 @@ module Clacky
 
       # Shared browser-like GET request — no Accept-Encoding to avoid gzip/br
       # detection tricks used by Bing. Supports redirect following.
-      private def http_get(url, accept_language: "en-US,en;q=0.9", follow_redirects: 0)
+      private def http_get(url, accept_language: "en-US,en;q=0.9", follow_redirects: 0, referer: nil)
         request = Net::HTTP::Get.new(url)
         request["User-Agent"] = USER_AGENTS.sample
         request["Accept"] = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
@@ -208,8 +258,9 @@ module Clacky
         # a JS-only skeleton (~39KB) instead of the real HTML results (~120KB)
         request["Sec-Fetch-Dest"] = "document"
         request["Sec-Fetch-Mode"] = "navigate"
-        request["Sec-Fetch-Site"] = "none"
+        request["Sec-Fetch-Site"] = referer ? "same-origin" : "none"
         request["Upgrade-Insecure-Requests"] = "1"
+        request["Referer"] = referer if referer
 
         response = Net::HTTP.start(url.hostname, url.port,
           use_ssl: url.scheme == "https",
@@ -220,7 +271,7 @@ module Clacky
         if follow_redirects > 0 && response.is_a?(Net::HTTPRedirection)
           location = response["location"]
           redirect_url = location.start_with?("http") ? URI(location) : URI("#{url.scheme}://#{url.hostname}#{location}")
-          return http_get(redirect_url, accept_language: accept_language, follow_redirects: follow_redirects - 1)
+          return http_get(redirect_url, accept_language: accept_language, follow_redirects: follow_redirects - 1, referer: referer)
         end
 
         response

data/lib/clacky/ui2/layout_manager.rb

@@ -119,18 +119,29 @@ module Clacky
 
         @render_mutex.synchronize do
           entry = @buffer.entry_by_id(id)
-          # Skip if gone, fully committed, or only partially visible (its
-          # prefix is already in terminal scrollback and cannot be edited).
-          return if entry.nil? || entry.committed
-          return if (entry.committed_line_offset || 0) > 0
+          if entry.nil?
+            Clacky::Logger.warn("[ph_debug] replace_entry_nil", id: id, content: content.to_s[0, 120])
+            return
+          end
+          if entry.committed
+            Clacky::Logger.warn("[ph_debug] replace_entry_committed", id: id, content: content.to_s[0, 120])
+            return
+          end
+          if (entry.committed_line_offset || 0) > 0
+            Clacky::Logger.warn("[ph_debug] replace_entry_partial", id: id, offset: entry.committed_line_offset, content: content.to_s[0, 120])
+            return
+          end
 
           old_lines = entry.lines.dup
           new_lines = wrap_content_to_lines(content)
           if old_lines == new_lines
+            Clacky::Logger.warn("[ph_debug] replace_entry_same", id: id)
             screen.flush
             return
           end
           @buffer.replace(id, new_lines)
+          is_tail = @buffer.live_entries.last&.id == id
+          Clacky::Logger.warn("[ph_debug] replace_entry_paint", id: id, is_tail: is_tail, old_n: old_lines.length, new_n: new_lines.length, content: content.to_s[0, 120])
 
           unless @fullscreen_mode
             # repaint_entry_in_place relies on the entry being the tail of
@@ -147,7 +158,6 @@ module Clacky
             # For non-tail replaces, fall back to a full rebuild of the
             # output area from the buffer. Slower, but correct regardless
             # of where the entry lives.
-            is_tail = @buffer.live_entries.last&.id == id
             if is_tail
               repaint_entry_in_place(entry, old_lines, new_lines)
             else

data/lib/clacky/ui2/progress_handle.rb

@@ -127,6 +127,7 @@ module Clacky
         @start_time    = nil
         @ticker        = nil
         @state         = :fresh     # :fresh → :running → :closed
+        @unregistered  = false
         @metadata      = {}
         @last_chunk_at = nil
         @monitor       = Monitor.new
@@ -172,29 +173,38 @@ module Clacky
       end
 
       # Stop the ticker, render one final frame, and unregister from the
-      # owner. Idempotent — calling twice is a no-op.
+      # owner. Idempotent and crash-safe — if a previous finish was
+      # interrupted (e.g. Thread#raise(AgentInterrupted) hit between
+      # +stop_ticker+ and +unregister_progress+), a follow-up finish
+      # will still complete the unregister so the handle does not stay
+      # orphaned on the owner's progress stack.
       #
       # @param final_message [String, nil] Optional override for the last
       #   frame. If nil, the handle composes "<message>… (<elapsed>s)".
       def finish(final_message: nil)
+        Clacky::Logger.warn("[ph_debug] finish_entry", oid: object_id, state: @state, unreg: @unregistered, msg: @message, eid: @entry_id)
         snapshot = @monitor.synchronize do
-          return if @state != :running
-          @state = :closed
-          { message: final_message || @message, elapsed: elapsed_seconds }
+          return if @unregistered
+          first_close = @state == :running
+          @state = :closed if first_close
+          {
+            first_close: first_close,
+            message: final_message || @message,
+            elapsed: elapsed_seconds,
+          }
         end
 
         stop_ticker
-        # Collapse fast-finishers to a removed entry so tools that complete
-        # in under FAST_FINISH_THRESHOLD_SECONDS don't leave a permanent
-        # "Executing foo… (0s)" line. The owner interprets final_frame: nil
-        # as "remove the entry entirely".
         final_frame =
           if @quiet_on_fast_finish && snapshot[:elapsed] < FAST_FINISH_THRESHOLD_SECONDS
             nil
           else
             compose_final_frame(snapshot[:message], snapshot[:elapsed])
           end
+        Clacky::Logger.warn("[ph_debug] finish_unregister", oid: object_id, eid: @entry_id, first_close: snapshot[:first_close], final_frame: final_frame.to_s[0, 200])
         @owner.unregister_progress(self, final_frame: final_frame)
+        @monitor.synchronize { @unregistered = true }
+        Clacky::Logger.warn("[ph_debug] finish_done", oid: object_id)
       end
       alias_method :cancel, :finish
 

data/lib/clacky/ui2/ui_controller.rb

@@ -655,6 +655,7 @@ module Clacky
 
       # Called by ProgressHandle#finish.
       def unregister_progress(handle, final_frame:)
+        Clacky::Logger.warn("[ph_debug] unreg_entry", oid: handle.object_id, eid: handle.entry_id, top: @progress_stack.last == handle, stack_size: @progress_stack.size, ff: final_frame.to_s[0, 200])
         @progress_mutex.synchronize do
           # If this handle still holds its entry (it's currently top), we
           # render one last frame there and release the id. If it was
@@ -662,10 +663,14 @@ module Clacky
           # is already gone and the final_frame is simply dropped.
           if handle.entry_id
             if final_frame && !final_frame.to_s.strip.empty?
+              Clacky::Logger.warn("[ph_debug] unreg_update_entry", oid: handle.object_id, eid: handle.entry_id)
               update_entry(handle.entry_id, @renderer.render_progress(final_frame))
             else
+              Clacky::Logger.warn("[ph_debug] unreg_remove_entry", oid: handle.object_id, eid: handle.entry_id)
               remove_entry(handle.entry_id)
             end
+          else
+            Clacky::Logger.warn("[ph_debug] unreg_no_entry_id", oid: handle.object_id)
           end
 
           @progress_stack.delete(handle)
@@ -873,6 +878,28 @@ module Clacky
         append_output(output)
       end
 
+      def phase_start(kind:, label:)
+        phase_id = SecureRandom.uuid
+        @active_phases ||= {}
+        @active_phases[phase_id] = { kind: kind, label: label, started_at: Time.now }
+        Thread.current[:clacky_phase_id] = phase_id
+
+        banner = "──────── ▼ #{label} ────────"
+        append_output(@renderer.render_system_message(banner, prefix_newline: true))
+        phase_id
+      end
+
+      def phase_end(phase_id, summary: nil)
+        Thread.current[:clacky_phase_id] = nil
+        return unless @active_phases&.key?(phase_id)
+
+        info = @active_phases.delete(phase_id)
+        label = info[:label]
+        tail = summary && !summary.to_s.strip.empty? ? " — #{summary.to_s.strip}" : ""
+        banner = "──────── ▲ #{label} done#{tail} ────────"
+        append_output(@renderer.render_system_message(banner, prefix_newline: false))
+      end
+
       # Set workspace status to idle (called when agent stops working)
       def set_idle_status
         # Safety net: close any legacy progress slots that were opened via

data/lib/clacky/ui_interface.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Clacky
   # UIInterface defines the standard interface between Agent/CLI and UI implementations.
   # All UI controllers (UIController, JsonUIController) must implement these methods.
@@ -136,5 +138,25 @@ module Clacky
     # === Path redaction (for encrypted brand skill tmpdirs) ===
     # === Lifecycle ===
     def stop(clear_screen: false); end
+
+    # === Phase grouping (optional, web UI uses this to fold subagent runs) ===
+    # Begin a logical phase. Events emitted between phase_start and phase_end
+    # carry the phase_id so the UI can group them visually.
+    # Returns the phase_id (caller is responsible for passing it to phase_end).
+    def phase_start(kind:, label: nil)
+      SecureRandom.uuid
+    end
+
+    def phase_end(phase_id, summary: nil); end
+
+    # Run block within a phase. Always closes via ensure.
+    def with_phase(kind:, label: nil)
+      pid = phase_start(kind: kind, label: label)
+      begin
+        yield pid
+      ensure
+        phase_end(pid)
+      end
+    end
   end
 end

data/lib/clacky/utils/model_pricing.rb

@@ -145,6 +145,47 @@ module Clacky
         }
       },
 
+      # Xiaomi MiMo — USD per 1M tokens, international (海外) list price.
+      # Source: https://platform.xiaomimimo.com/docs/zh-CN/price/pay-as-you-go
+      # Effective 2026-05-27 (V2.5 launch price cut). Cache write is "limited-
+      # time free" per Xiaomi's notice; per the project's "displayed ≤ actual"
+      # convention we bill writes at the input-miss rate so that when the
+      # promo ends users won't see a cost spike. Cache hits use the explicit
+      # cache-hit rate.
+      #
+      # As of 2026-06-01, mimo-v2-pro/omni are forwarded to the V2.5 series
+      # and billed at V2.5 rates; mimo-v2-pro mirrors mimo-v2.5-pro and
+      # mimo-v2-omni mirrors mimo-v2.5. Both will be retired 2026-06-30.
+      "mimo-v2.5-pro" => {
+        input:  { default: 0.435,   over_200k: 0.435 },
+        output: { default: 0.87,    over_200k: 0.87 },
+        cache:  { write: 0.435,     read: 0.0036 }
+      },
+
+      "mimo-v2.5" => {
+        input:  { default: 0.14,    over_200k: 0.14 },
+        output: { default: 0.28,    over_200k: 0.28 },
+        cache:  { write: 0.14,      read: 0.0028 }
+      },
+
+      "mimo-v2-pro" => {
+        input:  { default: 0.435,   over_200k: 0.435 },
+        output: { default: 0.87,    over_200k: 0.87 },
+        cache:  { write: 0.435,     read: 0.0036 }
+      },
+
+      "mimo-v2-omni" => {
+        input:  { default: 0.14,    over_200k: 0.14 },
+        output: { default: 0.28,    over_200k: 0.28 },
+        cache:  { write: 0.14,      read: 0.0028 }
+      },
+
+      "mimo-v2-flash" => {
+        input:  { default: 0.10,    over_200k: 0.10 },
+        output: { default: 0.30,    over_200k: 0.30 },
+        cache:  { write: 0.10,      read: 0.01 }
+      },
+
       # Kimi K2.5 / K2.6 multimodal models
       # Source: https://platform.moonshot.cn (USD / 1M tokens)
       # Kimi billing model (same shape as DeepSeek):
@@ -181,6 +222,38 @@ module Clacky
         }
       },
 
+      # Google Gemini 3 series (via Vertex AI). Tiered at 200K input tokens
+      # for Pro; Flash has flat pricing.
+      "gemini-3.1-pro" => {
+        input: {
+          default: 2.00,
+          over_200k: 4.00
+        },
+        output: {
+          default: 12.00,
+          over_200k: 18.00
+        },
+        cache: {
+          write: 2.00,
+          read: 0.50
+        }
+      },
+
+      "gemini-3-flash" => {
+        input: {
+          default: 0.50,
+          over_200k: 0.50
+        },
+        output: {
+          default: 3.00,
+          over_200k: 3.00
+        },
+        cache: {
+          write: 0.50,
+          read: 0.05
+        }
+      },
+
       # OpenAI GPT-5.5 / GPT-5.4 — breakpoint at 272K input tokens
       # Source: https://openai.com/api/pricing/ (USD / 1M tokens)
       # Note: OpenAI's actual tiered-pricing threshold is 272K, not the
@@ -581,6 +654,22 @@ module Clacky
         # non-thinking / thinking modes respectively. Bill at flash rates.
         when /^deepseek-chat$/i, /^deepseek-reasoner$/i
           "deepseek-v4-flash"
+        # Xiaomi MiMo — strict anchored match per registered model id in
+        # providers.rb (currently mimo-v2.5-pro / mimo-v2-pro / mimo-v2-omni).
+        # mimo-v2.5 / mimo-v2-flash are also priced ahead of provider-side
+        # registration. Per Xiaomi's 2026-06 schedule, mimo-v2-pro/omni are
+        # transparently routed to V2.5 — keys are listed independently so
+        # both old and new ids resolve to the right rate.
+        when /^mimo-v2\.?5-pro$/i
+          "mimo-v2.5-pro"
+        when /^mimo-v2\.?5$/i
+          "mimo-v2.5"
+        when /^mimo-v2-pro$/i
+          "mimo-v2-pro"
+        when /^mimo-v2-omni$/i
+          "mimo-v2-omni"
+        when /^mimo-v2-flash$/i
+          "mimo-v2-flash"
         # Kimi K2.5 / K2.6 — strict match only. K2 text-only models
         # (kimi-k2-0905-preview, kimi-k2-thinking, etc.) are not yet
         # registered in providers.rb and will be added in a follow-up
@@ -636,6 +725,13 @@ module Clacky
         when /^qwen3-vl-plus$/i
           "qwen3-vl-plus"
 
+        # Google Gemini 3 series. Match the platform aliases (or-gemini-*)
+        # and the bare upstream ids returned by Vertex.
+        when /^or-gemini-3-1-pro$/i, /^gemini-3\.1-pro(-preview)?$/i
+          "gemini-3.1-pro"
+        when /^or-gemini-3-5-flash$/i, /^gemini-3\.5-flash$/i, /^gemini-3-flash(-preview)?$/i
+          "gemini-3-flash"
+
         # OpenAI GPT-5.x models — match various dashed/dotted/compact forms
         # (e.g. "gpt-5.5", "gpt-5-5", "gpt5.5", "gpt55")
         when /^gpt-?5\.?5$/i, /^gpt-?5[\.-]?5$/i

data/lib/clacky/version.rb

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

data/lib/clacky/vision/resolver.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "digest"
+require "base64"
+require "fileutils"
+require "json"
+require_relative "../utils/file_processor"
+
+module Clacky
+  module Vision
+    # OCR sidecar — turns image bytes into a text description by calling a
+    # vision-capable model. Used when the user's primary model is text-only
+    # (e.g. DeepSeek V4) so that uploaded images and tool screenshots still
+    # reach the conversation as useful context.
+    #
+    # Routes through Clacky::Client so we get the same OpenAI/Anthropic/
+    # Bedrock format negotiation, retry, and credit-error handling as the
+    # main agent path. Image content travels as a canonical `image_url`
+    # block (the unified internal shape understood by all three formats).
+    class Resolver
+      DEFAULT_PROMPT = <<~PROMPT.strip
+        Extract every legible text and describe the visual content of this image.
+        Output as Markdown. Preserve table layout where possible (use Markdown tables).
+        For UI screenshots, describe the layout, visible labels, and active state.
+        Be thorough but concise — the user cannot see the image and must rely on
+        your description.
+      PROMPT
+
+      MAX_TOKENS = 8192
+      CACHE_DIR  = File.join(Dir.home, ".clacky", "ocr_cache")
+      CACHE_VERSION = 1
+
+      Result = Struct.new(:status, :text, :error, keyword_init: true) do
+        def ok?;          status == :ok;          end
+        def empty?;       status == :empty;       end
+        def call_failed?; status == :call_failed; end
+        def bad_image?;   status == :bad_image;   end
+      end
+
+      def initialize(model_entry)
+        @model_entry = model_entry
+        @model       = model_entry["model"]
+        @base_url    = model_entry["base_url"]
+        @api_key     = model_entry["api_key"]
+        @anthropic   = !!model_entry["anthropic_format"]
+      end
+
+      # @return [Result] one of:
+      #   status=:ok          + text   — sidecar produced a description
+      #   status=:empty               — sidecar returned 200 but no usable text (e.g. token budget exhausted by reasoning)
+      #   status=:call_failed + error — network/parse/auth error from the sidecar
+      #   status=:bad_image           — image bytes unreadable / empty
+      def describe(image, prompt: nil)
+        prompt = prompt.to_s.strip
+        prompt = DEFAULT_PROMPT if prompt.empty?
+
+        bytes, mime = read_image(image)
+        return Result.new(status: :bad_image) if bytes.nil? || bytes.empty?
+
+        cached = cache_get(bytes, prompt)
+        return Result.new(status: :ok, text: cached) if cached
+
+        text = call_vlm(bytes, mime, prompt)
+        return Result.new(status: :empty) if text.nil? || text.strip.empty?
+
+        cache_put(bytes, prompt, text)
+        Result.new(status: :ok, text: text)
+      rescue => e
+        Clacky::Logger.warn("[Vision::Resolver] failed: #{e.class}: #{e.message}") if defined?(Clacky::Logger)
+        Result.new(status: :call_failed, error: "#{e.class}: #{e.message}")
+      end
+
+      private def read_image(image)
+        if image[:bytes]
+          [image[:bytes], image[:mime_type] || "image/png"]
+        elsif image[:data_url] || image["data_url"]
+          url = image[:data_url] || image["data_url"]
+          m = url.match(/\Adata:([^;]+);base64,(.*)\z/m)
+          return [nil, nil] unless m
+          [Base64.decode64(m[2]), m[1]]
+        elsif image[:path] || image["path"]
+          path = image[:path] || image["path"]
+          return [nil, nil] unless File.exist?(path)
+          [File.binread(path), Utils::FileProcessor.detect_mime_type(path, nil) || "image/png"]
+        else
+          [nil, nil]
+        end
+      end
+
+      private def call_vlm(bytes, mime, prompt)
+        data_url = "data:#{mime};base64,#{Base64.strict_encode64(bytes)}"
+        message = {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image_url", image_url: { url: data_url } }
+          ]
+        }
+
+        client = Clacky::Client.new(
+          @api_key,
+          base_url: @base_url,
+          model: @model,
+          anthropic_format: @anthropic
+        )
+        response = client.send_messages([message], model: @model, max_tokens: MAX_TOKENS)
+        extract_text(response)
+      end
+
+      # Client#send_messages returns the raw upstream string for OpenAI/Anthropic;
+      # for Bedrock it returns the parsed text content. Normalise to String.
+      private def extract_text(response)
+        case response
+        when String then response
+        when Hash   then response[:content] || response["content"] || response.to_s
+        else response.to_s
+        end
+      end
+
+      # ── Cache ─────────────────────────────────────────────────────────────
+
+      private def cache_key(bytes, prompt)
+        sha = Digest::SHA256.hexdigest(bytes)
+        prompt_sha = Digest::SHA256.hexdigest(prompt)[0, 12]
+        "#{sha}_#{@model.gsub(/[^A-Za-z0-9_.-]/, '_')}_#{prompt_sha}"
+      end
+
+      private def cache_path(key)
+        File.join(CACHE_DIR, "#{key}.json")
+      end
+
+      private def cache_get(bytes, prompt)
+        path = cache_path(cache_key(bytes, prompt))
+        return nil unless File.exist?(path)
+        data = JSON.parse(File.read(path))
+        return nil unless data["v"] == CACHE_VERSION
+        data["text"]
+      rescue JSON::ParserError, Errno::ENOENT
+        nil
+      end
+
+      private def cache_put(bytes, prompt, text)
+        FileUtils.mkdir_p(CACHE_DIR)
+        path = cache_path(cache_key(bytes, prompt))
+        File.write(path, JSON.generate({
+          "v"     => CACHE_VERSION,
+          "model" => @model,
+          "text"  => text,
+          "ts"    => Time.now.to_i
+        }))
+      rescue => _
+        # Cache is best-effort — never fail the request because we can't write.
+        nil
+      end
+    end
+  end
+end