openclacky 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22bdc5132636582b787ebc49b43157871d15cfc0519a8ba93bc69fcfa9b58a2b
-  data.tar.gz: 97c40c43d3ae3252f81b1d3b92c89812cf28bdb181094d1fca6f5fea8ea9daa9
+  metadata.gz: 47f1d9f1ecb4338e0a19ce771dea37724ebfc70d9e0052dc7403e096a25c415d
+  data.tar.gz: 6887db06529972b393c75c92e17b47da8294abae765ceff7280d71943a160c85
 SHA512:
-  metadata.gz: 1c195480e06945b0a09e031498e5f1f4df5d5bb661ef123cf139cd570b33522a47475b8d698e3999a44de8979884e7e8f4dcc3adc424896965ad69cbac83902d
-  data.tar.gz: a151a7178e6541880ddad41930adf0e652571bb732cd82ba6b6c2de8e9d880e587a1e680d2c76a3dcb8f9609152f092b23a38afb1c443f8082b1f081d34d81da
+  metadata.gz: b49465d66eb2be634790d10813ac5988aca23f54a4d3c36c9690bd40bf0024ea5f7275b3bc1b89247aaa16cc30dbf1c1439733c51bdfc1f5750e02c7efbc8e80
+  data.tar.gz: f0f4397dd4cca183f199545e7c5db6b4902382c66c237257e8b2a99847e49702881dd8bcf60a78201ee18526ae2b04bd4217bf6def502ccf3ce8a7fb6fb0bdd0

data/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.2] - 2026-05-20
+
+### Added
+- Streaming response with real-time token display in WebUI
+- Stream thinking progress indicator during agent reasoning
+- Time-to-first-token (TTFT) display in WebUI
+- LaTeX rendering support in WebUI
+- Cache hit rate display in WebUI
+
+### Fixed
+- Reasoning content properly passed as `<think>` tags to WebUI
+- User-set session name no longer overwritten by auto-rename (#136)
+- Server command now supports `--help`/`-h`/`--bind`/`-b` and `-p` alias for `--port` (#135)
+- WSL.exe output encoding and premature WSL1 fallback detection (#130)
+- Hide edit/delete model options when no models are configured (#133)
+- BrowserManager MCP process cleanup on agent exit in CLI mode (#132)
+- Windows-native OpenClaw config detection on WSL during onboarding (#129)
+
+### More
+- Updated Windows installation docs and added GitHub star history
+
 ## [1.1.1] - 2026-05-17
 
 ### Added

data/README.md

@@ -18,7 +18,7 @@ Same task, how much do you pay? Under comparable agent workloads, OpenClacky sav
 
 | Agent | Relative cost | Notes |
 |---|---|---|
-| **OpenClacky** | **~0.8–1.2×** | 16 tools · ~100% cache hit · subagent routing |
+| **OpenClacky** | **~0.8** | 16 tools · ~100% cache hit · subagent routing |
 | Claude Code | 1.0× (baseline) | World-class harness, closed-source subscription |
 | OpenClaw | ~1.5× | Comparable harness agent |
 | Hermes | ~3× | 52 built-in tools — schema bloat ~3–4× |
@@ -31,11 +31,11 @@ Core agent capability is roughly on par across the field — the real differenti
 
 | Feature | Claude Code | OpenClaw | Hermes | **OpenClacky** |
 |---|:---:|:---:|:---:|:---:|
-| Token cost | 1.0× | ~1.5× | ~3× | **~0.8–1.2×** |
+| Token cost | 1.0× | ~1.5× | ~3× | **~0.8** |
 | Open source | ❌ Closed | ✅ Open | ✅ Open | ✅ MIT |
 | BYOK / model freedom | ❌ Anthropic only | ✅ | ✅ | ✅ |
 | Skill self-evolution | ❌ | ❌ | ✅ | ✅ |
-| IM integration (Feishu / WeCom / WeChat) | ❌ | ✅ | ✅ | ✅ |
+| IM integration (Feishu/WeCom/WeChat/Discord/Telegram) | ❌ | ✅ | ✅ | ✅ |
 
 ## How we get the cost down
 
@@ -80,18 +80,29 @@ More options: https://www.openclacky.com/
 
 ### Command line
 
-**Requirements:** Ruby >= 3.1.0
+One-line install(Mac/Ubuntu):
 
 ```bash
-gem install openclacky
+/bin/bash -c "$(curl -sSL https://raw.githubusercontent.com/clacky-ai/openclacky/main/scripts/install.sh)"
 ```
 
-Or one-line install:
+Windows:
 
 ```bash
-/bin/bash -c "$(curl -sSL https://raw.githubusercontent.com/clacky-ai/openclacky/main/scripts/install.sh)"
+powershell -c "& ([scriptblock]::Create((irm 'https://raw.githubusercontent.com/clacky-ai/openclacky/main/scripts/install.ps1')))"
 ```
 
+or using Ruby(3.x/4.x):
+
+**Requirements:** Ruby >= 3.1.0
+
+```bash
+gem install openclacky
+```
+
+see more: https://www.openclacky.com/docs/installation
+
+
 ## Quick Start
 
 ### Terminal (CLI)
@@ -137,6 +148,16 @@ $ openclacky
 > How does the payment module work?
 ```
 
+## Star History
+
+<a href="https://www.star-history.com/?repos=clacky-ai%2Fopenclacky&type=date&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=clacky-ai/openclacky&type=date&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=clacky-ai/openclacky&type=date&legend=top-left" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=clacky-ai/openclacky&type=date&legend=top-left" />
+ </picture>
+</a>
+
 ## Advanced — Creator Program
 
 Already power users are turning their workflows into vertical AI experts on OpenClacky — encrypted distribution, License management, self-set pricing. Legal, healthcare, financial planning, and more.

data/lib/clacky/agent/llm_caller.rb

@@ -103,7 +103,8 @@ module Clacky
             model: current_model,
             tools: tools_to_send,
             max_tokens: @config.max_tokens,
-            enable_caching: @config.enable_prompt_caching
+            enable_caching: @config.enable_prompt_caching,
+            on_chunk: build_progress_on_chunk
           )
 
           # Successful response — if we were probing, confirm primary is healthy.
@@ -748,6 +749,27 @@ module Clacky
           "Upstream response was truncated mid tool-call — asking model to use smaller steps and retrying..."
         )
       end
+
+      # Build a streaming progress callback for Client#send_messages_with_tools.
+      # Returns nil when no UI is attached, so the client skips the streaming
+      # plumbing entirely. Callback throttles UI updates to avoid flooding the
+      # progress handle on fast streams.
+      private def build_progress_on_chunk
+        return nil unless @ui
+
+        last_emit_at = 0.0
+        min_interval = 0.25
+        ->(input_tokens:, output_tokens:) {
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          return if now - last_emit_at < min_interval && output_tokens > 0
+          last_emit_at = now
+          @ui.show_progress(
+            progress_type: "thinking",
+            phase: "active",
+            metadata: { input_tokens: input_tokens, output_tokens: output_tokens }
+          )
+        }
+      end
     end
   end
 end

data/lib/clacky/agent/session_serializer.rb

@@ -471,8 +471,13 @@ module Clacky
 
         case msg[:role].to_s
         when "assistant"
-          # Text content
+          # Text content — prepend reasoning/thinking content wrapped in <think> tags
+          # so the Web UI renders it as a collapsible thinking block
           text = extract_text_from_content(msg[:content]).to_s.strip
+          reasoning = msg[:reasoning_content]
+          if reasoning && !reasoning.to_s.strip.empty?
+            text = "<think>\n#{reasoning}\n</think>\n#{text}"
+          end
           ui.show_assistant_message(text, files: []) unless text.empty?
 
           # Tool calls embedded in assistant message

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,7 +955,13 @@ 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.