openclacky 1.1.1 → 1.1.3

data/lib/clacky/agent.rb

@@ -427,7 +427,7 @@ module Clacky
               tool_calls_count: (response[:tool_calls] || []).size
             )
             if response[:content] && !response[:content].empty?
-              emit_assistant_message(response[:content])
+              emit_assistant_message(response[:content], reasoning_content: response[:reasoning_content])
             end
 
             # Show token usage after the assistant message so WebUI renders it below the bubble
@@ -448,7 +448,7 @@ module Clacky
 
           # Show assistant message if there's content before tool calls
           if response[:content] && !response[:content].empty?
-            emit_assistant_message(response[:content])
+            emit_assistant_message(response[:content], reasoning_content: response[:reasoning_content])
           end
 
           # Show token usage after assistant message (or immediately if no message).
@@ -1532,11 +1532,20 @@ module Clacky
     # and cannot load file:// directly) and must stay scoped to the Web UI
     # controller. IM channel subscribers need the original file:// markdown so
     # parse_file_links can extract paths and deliver images as native attachments.
-    private def emit_assistant_message(content)
-      return if content.nil? || content.empty?
+    private def emit_assistant_message(content, reasoning_content: nil)
+      # Prepend reasoning/thinking content (from thinking-mode providers like
+      # DeepSeek V4, Kimi K2) wrapped in <think> tags so the Web UI renders it
+      # as a collapsible thinking block (see sessions.js _renderMarkdown).
+      if reasoning_content && !reasoning_content.to_s.strip.empty?
+        full_content = "<think>\n#{reasoning_content}\n</think>\n#{content}"
+      else
+        full_content = content
+      end
+
+      return if full_content.nil? || full_content.to_s.strip.empty?
 
       parsed = parse_file_links(content)
-      @ui&.show_assistant_message(parsed[:text], files: parsed[:files])
+      @ui&.show_assistant_message(full_content, files: parsed[:files])
     end
 
     # Track modified files for Time Machine snapshots

data/lib/clacky/anthropic_stream_aggregator.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Clacky
+  # Reassembles an Anthropic Messages SSE stream (event: message_start /
+  # content_block_start / content_block_delta / content_block_stop /
+  # message_delta / message_stop / ping) into the same hash shape that
+  # MessageFormat::Anthropic.parse_response expects from a non-streaming
+  # response, while invoking on_chunk(input_tokens:, output_tokens:) as
+  # usage accumulates.
+  #
+  # Wire reference: https://docs.anthropic.com/en/api/messages-streaming
+  class AnthropicStreamAggregator
+    def initialize(on_chunk: nil)
+      @on_chunk = on_chunk
+      @blocks = {}
+      @stop_reason = nil
+      @usage = {}
+      @last_input_tokens = 0
+      @last_output_tokens = 0
+    end
+
+    def handle(event, data_str)
+      data = parse_or_nil(data_str)
+      return unless data
+
+      case event
+      when "message_start"
+        msg = data["message"] || {}
+        if (u = msg["usage"])
+          @usage.merge!(u)
+          emit_usage_progress
+        end
+      when "content_block_start"
+        idx = data["index"] || @blocks.size
+        cb = data["content_block"] || {}
+        case cb["type"]
+        when "tool_use"
+          @blocks[idx] = { kind: :tool_use, id: cb["id"], name: cb["name"], input_str: +"" }
+        else
+          @blocks[idx] = { kind: :text, text: +"" }
+        end
+      when "content_block_delta"
+        idx = data["index"] || 0
+        delta = data["delta"] || {}
+        block = (@blocks[idx] ||= { kind: :text, text: +"" })
+        case delta["type"]
+        when "text_delta"
+          block[:kind] ||= :text
+          block[:text] ||= +""
+          block[:text] << delta["text"].to_s
+        when "input_json_delta"
+          block[:kind] = :tool_use
+          block[:input_str] ||= +""
+          block[:input_str] << delta["partial_json"].to_s
+        when "thinking_delta"
+          block[:kind] = :thinking
+          block[:thinking] ||= +""
+          block[:thinking] << delta["thinking"].to_s
+        end
+        emit_estimate_progress
+      when "content_block_stop"
+        # Nothing to do: blocks are finalised in to_h.
+      when "message_delta"
+        if (d = data["delta"])
+          @stop_reason = d["stop_reason"] if d["stop_reason"]
+        end
+        if (u = data["usage"])
+          @usage.merge!(u)
+          emit_usage_progress
+        end
+      when "message_stop", "ping", "error"
+        # no-op
+      end
+    end
+
+    # Canonical non-streaming Anthropic response shape consumed by
+    # MessageFormat::Anthropic.parse_response.
+    def to_h
+      content_blocks = @blocks.keys.sort.map do |idx|
+        b = @blocks[idx]
+        case b[:kind]
+        when :tool_use
+          input_value =
+            if b[:input_str].to_s.empty?
+              {}
+            else
+              JSON.parse(b[:input_str]) rescue b[:input_str]
+            end
+          { "type" => "tool_use", "id" => b[:id], "name" => b[:name], "input" => input_value }
+        else
+          { "type" => "text", "text" => b[:text].to_s }
+        end
+      end
+
+      { "content" => content_blocks, "stop_reason" => @stop_reason, "usage" => @usage }
+    end
+
+    private def parse_or_nil(s)
+      JSON.parse(s)
+    rescue JSON::ParserError
+      nil
+    end
+
+    private def emit_usage_progress
+      return unless @on_chunk
+      input  = @usage["input_tokens"].to_i + @usage["cache_read_input_tokens"].to_i
+      output = @usage["output_tokens"].to_i
+      return if input == @last_input_tokens && output == @last_output_tokens
+      @last_input_tokens = input
+      @last_output_tokens = output
+      @on_chunk.call(input_tokens: input, output_tokens: output)
+    rescue => e
+      Clacky::Logger.warn("[AnthropicStreamAggregator] on_chunk: #{e.class}: #{e.message}")
+    end
+
+    private def emit_estimate_progress
+      return unless @on_chunk
+      output = approximate_output_tokens
+      return if output == @last_output_tokens
+      @last_output_tokens = output
+      @on_chunk.call(input_tokens: @last_input_tokens, output_tokens: output)
+    rescue => e
+      Clacky::Logger.warn("[AnthropicStreamAggregator] on_chunk: #{e.class}: #{e.message}")
+    end
+
+    private def approximate_output_tokens
+      total_chars = @blocks.values.sum do |b|
+        b[:text].to_s.bytesize + b[:input_str].to_s.bytesize + b[:thinking].to_s.bytesize
+      end
+      (total_chars / 4.0).ceil
+    end
+  end
+end

data/lib/clacky/bedrock_stream_aggregator.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Clacky
+  # Reassembles a Bedrock Converse event stream into the same hash shape that
+  # MessageFormat::Bedrock.parse_response expects from a non-streaming response,
+  # while invoking on_chunk(input_tokens:, output_tokens:) as usage information
+  # accumulates.
+  #
+  # Bedrock event-stream events handled (passed through as raw event JSON):
+  #
+  #   messageStart      → { role: "assistant" }
+  #   contentBlockStart → { start: {toolUse: {toolUseId, name}} | {}, contentBlockIndex: N }
+  #   contentBlockDelta → { delta: {text: "..."} | {toolUse: {input: "..."}}, contentBlockIndex: N }
+  #   contentBlockStop  → { contentBlockIndex: N }
+  #   messageStop       → { stopReason: "end_turn" | "tool_use" | "max_tokens" | ... }
+  #   metadata          → { usage: {inputTokens, outputTokens, cacheReadInputTokens, cacheWriteInputTokens}, metrics: {...} }
+  #
+  # Tool-use input is streamed as a sequence of partial JSON strings; we
+  # concatenate and let the response parser leave it as a string for downstream
+  # tool dispatch (which calls JSON.parse with a {} fallback).
+  class BedrockStreamAggregator
+    def initialize(on_chunk: nil)
+      @on_chunk = on_chunk
+      @role = "assistant"
+      @blocks = {}
+      @stop_reason = nil
+      @usage = {}
+      @last_input_tokens = 0
+      @last_output_tokens = 0
+    end
+
+    def handle(event, data_str)
+      data = parse_or_nil(data_str)
+      return unless data
+
+      case event
+      when "messageStart"
+        @role = data["role"] || @role
+      when "contentBlockStart"
+        idx = data["contentBlockIndex"] || @blocks.size
+        start = data["start"] || {}
+        if (tu = start["toolUse"])
+          @blocks[idx] = { kind: :tool_use, id: tu["toolUseId"], name: tu["name"], input_str: +"" }
+        else
+          @blocks[idx] = { kind: :text, text: +"" }
+        end
+      when "contentBlockDelta"
+        idx = data["contentBlockIndex"] || 0
+        delta = data["delta"] || {}
+        block = (@blocks[idx] ||= { kind: :text, text: +"" })
+        if delta["text"]
+          block[:kind] ||= :text
+          block[:text] ||= +""
+          block[:text] << delta["text"]
+        elsif (tu = delta["toolUse"])
+          block[:kind] = :tool_use
+          block[:input_str] ||= +""
+          block[:input_str] << tu["input"].to_s
+          block[:id]   ||= tu["toolUseId"]
+          block[:name] ||= tu["name"]
+        elsif (rc = delta["reasoningContent"])
+          block[:kind] = :reasoning
+          block[:reasoning] ||= +""
+          block[:reasoning] << rc["text"].to_s
+        end
+        emit_estimate_progress
+      when "contentBlockStop"
+        # Nothing to assemble: blocks are kept as-is until messageStop.
+      when "messageStop"
+        @stop_reason = data["stopReason"] || @stop_reason
+      when "metadata"
+        if (u = data["usage"])
+          @usage.merge!(u)
+          emit_usage_progress(u)
+        end
+      end
+    end
+
+    # Render the canonical non-streaming Bedrock response hash so the existing
+    # MessageFormat::Bedrock.parse_response can consume it unchanged.
+    def to_h
+      content_blocks = @blocks.keys.sort.map do |idx|
+        b = @blocks[idx]
+        case b[:kind]
+        when :tool_use
+          input_value = b[:input_str].to_s.empty? ? {} : (JSON.parse(b[:input_str]) rescue b[:input_str])
+          { "toolUse" => { "toolUseId" => b[:id], "name" => b[:name], "input" => input_value } }
+        else
+          { "text" => b[:text].to_s }
+        end
+      end
+
+      {
+        "output"     => { "message" => { "role" => @role, "content" => content_blocks } },
+        "stopReason" => @stop_reason,
+        "usage"      => @usage
+      }
+    end
+
+    private def parse_or_nil(s)
+      JSON.parse(s)
+    rescue JSON::ParserError
+      nil
+    end
+
+    private def emit_usage_progress(u)
+      return unless @on_chunk
+      input  = u["inputTokens"].to_i + u["cacheReadInputTokens"].to_i
+      output = u["outputTokens"].to_i
+      return if input == @last_input_tokens && output == @last_output_tokens
+      @last_input_tokens = input
+      @last_output_tokens = output
+      @on_chunk.call(input_tokens: input, output_tokens: output)
+    rescue => e
+      Clacky::Logger.warn("[BedrockStreamAggregator] on_chunk: #{e.class}: #{e.message}")
+    end
+
+    private def emit_estimate_progress
+      return unless @on_chunk
+      output = approximate_output_tokens
+      return if output == @last_output_tokens
+      @last_output_tokens = output
+      @on_chunk.call(input_tokens: @last_input_tokens, output_tokens: output)
+    rescue => e
+      Clacky::Logger.warn("[BedrockStreamAggregator] on_chunk: #{e.class}: #{e.message}")
+    end
+
+    private def approximate_output_tokens
+      total_chars = @blocks.values.sum do |b|
+        b[:text].to_s.bytesize + b[:input_str].to_s.bytesize + b[:reasoning].to_s.bytesize
+      end
+      (total_chars / 4.0).ceil
+    end
+  end
+end

data/lib/clacky/cli.rb

@@ -163,6 +163,7 @@ module Clacky
         end
       ensure
         Dir.chdir(original_dir)
+        Clacky::BrowserManager.instance.stop rescue nil
       end
     end
 
@@ -942,8 +943,8 @@ module Clacky
         $ clacky server
         $ clacky server --port 8080
     LONGDESC
-    option :host, type: :string, default: "127.0.0.1", desc: "Bind host (default: 127.0.0.1)"
-    option :port, type: :numeric, default: 7070, desc: "Listen port (default: 7070)"
+    option :host, type: :string, aliases: ["-b", "--bind"], default: "127.0.0.1", desc: "Bind host (default: 127.0.0.1)"
+    option :port, type: :numeric, aliases: "-p", default: 7070, desc: "Listen port (default: 7070)"
     option :brand_test, type: :boolean, default: false,
            desc: "Enable brand test mode: mock license activation without calling remote API"
     option :no_compression, type: :boolean, default: false,
@@ -954,11 +955,17 @@ module Clacky
            desc: "Disable prompt caching"
     option :no_skill_evolution, type: :boolean, default: false,
            desc: "Disable automatic skill evolution"
+    option :help, type: :boolean, aliases: "-h", desc: "Show this help message"
     def server
+      if options[:help]
+        invoke :help, ["server"]
+        return
+      end
+
       # ── Security gate ──────────────────────────────────────────────────────
       # Binding to 0.0.0.0 exposes the server to the public network.
       # Refuse to start unless CLACKY_ACCESS_KEY env var is set.
-      if options[:host] == "0.0.0.0" && ENV.fetch("CLACKY_ACCESS_KEY", "").strip.empty?
+      if options[:host] == "0.0.0.0" && !ENV.key?("CLACKY_ACCESS_KEY")
         puts <<~MSG
           ╔══════════════════════════════════════════════════════════════╗
           ║  ⚠️  Security Warning: Refusing to start                      ║

data/lib/clacky/client.rb

@@ -119,37 +119,59 @@ module Clacky
     #   signal metric — see docs). When we migrate to streaming later, this
     #   same `ttft_ms` field will start carrying the *actual* first-token
     #   latency without any schema change.
-    def send_messages_with_tools(messages, model:, tools:, max_tokens:, enable_caching: false)
+    # @param on_chunk [Proc, nil] optional streaming progress callback.
+    #   Receives keyword args { input_tokens:, output_tokens: } with cumulative
+    #   token counts. When nil, behaves exactly as the historical non-streaming
+    #   path. When given but streaming is not yet wired for the active provider,
+    #   a single synthetic invocation is fired after the response is received,
+    #   so UI plumbing can be exercised end-to-end without the proxy work.
+    def send_messages_with_tools(messages, model:, tools:, max_tokens:, enable_caching: false, on_chunk: nil)
       caching_enabled = enable_caching && supports_prompt_caching?(model)
       cloned = deep_clone(messages)
 
+      streaming_used = false
+      first_chunk_at = nil
+      wrapped_on_chunk = on_chunk && lambda do |**kwargs|
+        first_chunk_at ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        on_chunk.call(**kwargs)
+      end
+
       t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       response =
         if bedrock?
-          send_bedrock_request(cloned, model, tools, max_tokens, caching_enabled)
+          streaming_used = !on_chunk.nil?
+          send_bedrock_request(cloned, model, tools, max_tokens, caching_enabled, on_chunk: wrapped_on_chunk)
         elsif anthropic_format?
-          send_anthropic_request(cloned, model, tools, max_tokens, caching_enabled)
+          streaming_used = !on_chunk.nil?
+          send_anthropic_request(cloned, model, tools, max_tokens, caching_enabled, on_chunk: wrapped_on_chunk)
         else
-          send_openai_request(cloned, model, tools, max_tokens, caching_enabled)
+          streaming_used = !on_chunk.nil?
+          send_openai_request(cloned, model, tools, max_tokens, caching_enabled, on_chunk: wrapped_on_chunk)
         end
       t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      if on_chunk && !streaming_used
+        usage = response[:usage] || {}
+        safe_invoke_on_chunk(
+          on_chunk,
+          input_tokens:  usage[:prompt_tokens].to_i,
+          output_tokens: usage[:completion_tokens].to_i
+        )
+      end
+
       duration_ms = ((t1 - t0) * 1000).round
-      # Throughput is only meaningful with a reasonable output size; below ~10
-      # tokens the sample is too small to be informative and the result is
-      # wildly high (e.g. 1 token / 50ms → 20 tok/s is meaningless).
-      # Canonical usage hashes from message_format/* all use :completion_tokens.
+      ttft_ms = first_chunk_at ? ((first_chunk_at - t0) * 1000).round : duration_ms
       output_tokens = response[:usage]&.dig(:completion_tokens).to_i
       tps = (output_tokens >= 10 && duration_ms > 0) ? (output_tokens * 1000.0 / duration_ms).round(1) : nil
 
       response[:latency] = {
-        ttft_ms:     duration_ms,      # non-streaming: TTFT == full duration
+        ttft_ms:     ttft_ms,
         duration_ms: duration_ms,
         output_tokens: output_tokens,
         tps:         tps,
         model:       model,
         measured_at: Time.now.to_f,
-        streaming:   false              # future flag — true when we migrate
+        streaming:   streaming_used
       }
       response
     end
@@ -195,8 +217,10 @@ module Clacky
 
     # ── Bedrock Converse request / response ───────────────────────────────────
 
-    def send_bedrock_request(messages, model, tools, max_tokens, caching_enabled)
-      body     = MessageFormat::Bedrock.build_request_body(messages, model, tools, max_tokens, caching_enabled)
+    def send_bedrock_request(messages, model, tools, max_tokens, caching_enabled, on_chunk: nil)
+      body = MessageFormat::Bedrock.build_request_body(messages, model, tools, max_tokens, caching_enabled)
+      return send_bedrock_stream_request(body, model, on_chunk) if on_chunk
+
       response = bedrock_connection.post(bedrock_endpoint(model)) { |r| r.body = body.to_json }
 
       raise_error(response) unless response.status == 200
@@ -205,6 +229,29 @@ module Clacky
       MessageFormat::Bedrock.parse_response(parsed_body)
     end
 
+    # Streaming variant for Bedrock Converse.
+    # Posts to /model/{m}/converse-stream with stream:true; the proxy returns
+    # SSE frames whose `event` is the Bedrock event-type and whose `data` is
+    # the raw Bedrock event JSON. We accumulate frames into a synthetic
+    # non-streaming response and feed it back through the existing parser so
+    # downstream code is identical.
+    private def send_bedrock_stream_request(body, model, on_chunk)
+      stream_body = body.merge(stream: true)
+      aggregator = BedrockStreamAggregator.new(on_chunk: on_chunk)
+      sse_buf = +""
+
+      response = bedrock_connection.post(bedrock_stream_endpoint(model)) do |req|
+        req.body = stream_body.to_json
+        req.options.on_data = proc do |chunk, _bytes_received, _env|
+          sse_buf << chunk
+          drain_sse_frames(sse_buf) { |event, data| aggregator.handle(event, data) }
+        end
+      end
+
+      raise_error(response) unless response.status == 200
+      MessageFormat::Bedrock.parse_response(aggregator.to_h)
+    end
+
     def parse_simple_bedrock_response(response)
       raise_error(response) unless response.status == 200
       data = safe_json_parse(response.body, context: "LLM response")
@@ -216,11 +263,13 @@ module Clacky
 
     # ── Anthropic request / response ──────────────────────────────────────────
 
-    def send_anthropic_request(messages, model, tools, max_tokens, caching_enabled)
+    def send_anthropic_request(messages, model, tools, max_tokens, caching_enabled, on_chunk: nil)
       # Apply cache_control to the message that marks the cache breakpoint
       messages = apply_message_caching(messages) if caching_enabled
 
-      body     = MessageFormat::Anthropic.build_request_body(messages, model, tools, max_tokens, caching_enabled)
+      body = MessageFormat::Anthropic.build_request_body(messages, model, tools, max_tokens, caching_enabled)
+      return send_anthropic_stream_request(body, on_chunk) if on_chunk
+
       response = anthropic_connection.post(anthropic_messages_path) { |r| r.body = body.to_json }
 
       raise_error(response) unless response.status == 200
@@ -229,6 +278,24 @@ module Clacky
       MessageFormat::Anthropic.parse_response(parsed_body)
     end
 
+    private def send_anthropic_stream_request(body, on_chunk)
+      stream_body = body.merge(stream: true)
+      aggregator = AnthropicStreamAggregator.new(on_chunk: on_chunk)
+      sse_buf = +""
+
+      response = anthropic_connection.post(anthropic_messages_path) do |req|
+        req.headers["Accept"] = "text/event-stream"
+        req.body = stream_body.to_json
+        req.options.on_data = proc do |chunk, _bytes_received, _env|
+          sse_buf << chunk
+          drain_sse_frames(sse_buf) { |event, data| aggregator.handle(event, data) }
+        end
+      end
+
+      raise_error(response) unless response.status == 200
+      MessageFormat::Anthropic.parse_response(aggregator.to_h)
+    end
+
     def parse_simple_anthropic_response(response)
       raise_error(response) unless response.status == 200
       data = safe_json_parse(response.body, context: "LLM response")
@@ -237,24 +304,47 @@ module Clacky
 
     # ── OpenAI request / response ─────────────────────────────────────────────
 
-    def send_openai_request(messages, model, tools, max_tokens, caching_enabled)
+    def send_openai_request(messages, model, tools, max_tokens, caching_enabled, on_chunk: nil)
       # Apply cache_control markers to messages when caching is enabled.
       # OpenRouter proxies Claude with the same cache_control field convention as Anthropic direct.
       messages = apply_message_caching(messages) if caching_enabled
 
-      body     = MessageFormat::OpenAI.build_request_body(
+      body = MessageFormat::OpenAI.build_request_body(
         messages, model, tools, max_tokens, caching_enabled,
         vision_supported: @vision_supported
       )
+      return send_openai_stream_request(body, on_chunk) if on_chunk
+
       response = openai_connection.post("chat/completions") { |r| r.body = body.to_json }
 
       raise_error(response) unless response.status == 200
       check_html_response(response)
-      
+
       parsed_body = safe_json_parse(response.body, context: "LLM response")
       MessageFormat::OpenAI.parse_response(parsed_body)
     end
 
+    # Streaming variant for OpenAI-compatible chat completions (DeepSeek/OpenRouter
+    # via platform/llm_proxy). Uses Faraday's on_data hook to consume SSE frames,
+    # accumulates them, and reconstructs the non-streaming JSON response shape so
+    # MessageFormat::OpenAI.parse_response works unchanged.
+    private def send_openai_stream_request(body, on_chunk)
+      stream_body = body.merge(stream: true, stream_options: { include_usage: true })
+      aggregator = OpenAIStreamAggregator.new(on_chunk: on_chunk)
+      sse_buf = +""
+
+      response = openai_connection.post("chat/completions") do |req|
+        req.body = stream_body.to_json
+        req.options.on_data = proc do |chunk, _bytes_received, _env|
+          sse_buf << chunk
+          drain_sse_frames(sse_buf) { |_event, data| aggregator.handle(data) }
+        end
+      end
+
+      raise_error(response) unless response.status == 200
+      MessageFormat::OpenAI.parse_response(aggregator.to_h)
+    end
+
     def parse_simple_openai_response(response)
       raise_error(response) unless response.status == 200
       parsed_body = safe_json_parse(response.body, context: "LLM response")
@@ -320,6 +410,33 @@ module Clacky
       "/model/#{model}/converse"
     end
 
+    # Bedrock Converse streaming endpoint path.
+    private def bedrock_stream_endpoint(model)
+      "/model/#{model}/converse-stream"
+    end
+
+    # Pull complete SSE frames out of a buffer and yield them as (event, data).
+    # An SSE frame ends at a blank line ("\n\n"); incomplete trailing data
+    # stays in the buffer for the next chunk. Frames without an explicit
+    # `event:` line use the default "message" type per the SSE spec.
+    private def drain_sse_frames(buf)
+      while (sep = buf.index("\n\n"))
+        frame = buf.slice!(0, sep + 2)
+        event = "message"
+        data_lines = []
+        frame.each_line do |line|
+          line = line.chomp
+          if line.start_with?("event:")
+            event = line.sub(/^event:\s*/, "")
+          elsif line.start_with?("data:")
+            data_lines << line.sub(/^data:\s*/, "")
+          end
+        end
+        next if data_lines.empty?
+        yield event, data_lines.join("\n")
+      end
+    end
+
     def bedrock_connection
       @bedrock_connection ||= Faraday.new(url: @base_url) do |conn|
         conn.headers["Content-Type"]  = "application/json"
@@ -477,6 +594,18 @@ module Clacky
                            "The request will be retried automatically."
     end
 
+    # ── Streaming helpers ─────────────────────────────────────────────────────
+
+    # Invoke the user's on_chunk callback in a way that never lets a callback
+    # error tear down the LLM request. Streaming chunks are best-effort UI
+    # updates; a buggy progress renderer must not abort an in-flight call.
+    private def safe_invoke_on_chunk(on_chunk, **kwargs)
+      return unless on_chunk
+      on_chunk.call(**kwargs)
+    rescue => e
+      Clacky::Logger.warn("[on_chunk] callback raised #{e.class}: #{e.message}")
+    end
+
     # ── Utilities ─────────────────────────────────────────────────────────────
 
     def deep_clone(obj)

data/lib/clacky/default_skills/onboard/SKILL.md

@@ -221,8 +221,12 @@ then parse the last stdout line as JSON and read `installed` as N.
 
 ### A.10. Import external skills (optional)
 
-Run `test -d ~/.openclaw && echo yes || echo no`. If `no`, skip silently.
-If `yes`:
+Check if OpenClaw is installed:
+- Run `test -d ~/.openclaw && echo yes || echo no`
+- If `no` and on WSL (i.e. `/proc/version` contains `microsoft`), also run:
+  `powershell.exe -NoProfile -Command '$env:USERPROFILE' 2>/dev/null | tr -d '\r'` to get the Windows home, then check `test -d "$(wslpath '<win_home>')/.openclaw" && echo yes || echo no`
+- If all checks return `no`, skip silently.
+If any check returns `yes`:
 1. `ruby "SKILL_DIR/scripts/import_external_skills.rb" --source openclaw --dry-run`
 2. Parse the skill count N.
 3. Ask via `request_user_feedback`: