openclacky 0.9.17 → 0.9.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dd996048847d73d0a71f8d4833f338e4c5ae2a58c6228122b817039f2d9fda4
-  data.tar.gz: 2003df86f0c4446d6f3d6b7d0c14eef19cc05246735acdd1f79910a0cfb0a324
+  metadata.gz: b959a76ace0015ec6279b1572afa3e961d862d9c856c9fdecc98f72d9e190e59
+  data.tar.gz: 53cc27fce3b47e83cb428955eb6591d53acc148cdab55721c7c32330b351fed0
 SHA512:
-  metadata.gz: ab9f7d2b510bdf5dc4736723dbfa602968a584f2d097d4747af4f5c74247f494e66d32a0420c7f7aa4b5e87662d5662671ab3c56e12bdb627bd7b4766504fda9
-  data.tar.gz: 4e5543ac5c01d46b5be821769c1505de6797746991fa9605788a1036ed334fa03d6a3c2d7546706dcd0bde5595d94812196acbd51df8e56008c7ba493c1058ec
+  metadata.gz: 5b0d27875497a290060cabfc409c5b8a18b90b95c8bec82157f8d1f8e63a25fc78e3d52bff8bcbf3bd9969f8e65090137dc7ce7b394ac35779412a51534a166e
+  data.tar.gz: 2b08d76c821e84c7196b4bc6364323879669259895b30cb803e01e70c49a59f44a40f5f607f8a4d3e10a96bfaa47167c03ed991fcebe6a5dcb44d099b18bdccd

data/.clacky/skills/oss-upload/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: oss-upload
+description: Upload local files to Tencent COS (oss.1024code.com CDN) using coscli. Use when user wants to upload a file to CDN/OSS, or deploy static assets.
+---
+
+# OSS Upload Skill
+
+Upload files to Tencent COS bucket `clackyai-1258723534`, served via `https://oss.1024code.com`.
+
+## Tool
+`coscli` — config at `~/.cos.yaml`
+
+## Bucket Info
+- Bucket: `clackyai-1258723534`
+- Region: `ap-guangzhou`
+- Endpoint: `cos.ap-guangzhou.myqcloud.com`
+- Public CDN: `https://oss.1024code.com/<path>`
+
+## Upload Command
+
+```bash
+coscli cp <local-file> cos://clackyai-1258723534/<remote-path>
+```
+
+### Examples
+
+```bash
+# Upload a single file to bucket root
+coscli cp /tmp/wsl.2.6.3.0.arm64.msi cos://clackyai-1258723534/wsl.2.6.3.0.arm64.msi
+
+# Upload to a subdirectory
+coscli cp /tmp/install.ps1 cos://clackyai-1258723534/clacky-ai/openclacky/main/scripts/install.ps1
+
+# Upload entire directory recursively
+coscli cp /tmp/dist/ cos://clackyai-1258723534/dist/ -r
+```
+
+## Public URL
+After upload, the file is accessible at:
+```
+https://oss.1024code.com/<remote-path>
+```
+
+## Steps
+1. Confirm local file exists
+2. Run `coscli cp <local> cos://clackyai-1258723534/<path>`
+3. Return the public URL: `https://oss.1024code.com/<path>`

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.19] - 2026-03-29
+
+### Added
+- **Bing search engine support**: the web search tool now supports Bing in addition to DuckDuckGo and Baidu — improves search coverage and fallback reliability
+- **WSL1 fallback for Windows installer**: the PowerShell installer now automatically falls back to WSL1 when WSL2/Hyper-V is unavailable, ensuring installation succeeds on older or constrained Windows machines
+- **Upgrade via OSS (CN mirror)**: the upgrade flow now downloads new gem versions from Tencent OSS, making upgrades faster and more reliable for users in China
+
+### Fixed
+- **WeChat (Weixin) context token refresh**: the WeChat channel adapter now correctly refreshes the access token when it expires, preventing message delivery failures
+- **DOCX parser UTF-8 encoding bug**: parsing `.docx` files with non-ASCII content no longer causes encoding errors
+- **WSL version detection broadened**: installer now correctly handles old inbox `wsl.exe` (exit code -1) in addition to "feature not enabled" (exit code 1)
+- **Ctrl+C handling in UI**: Ctrl+C now correctly interrupts the current operation without leaving the UI in a broken state
+- **Layout scrollback double-render**: fixed a UI rendering issue that caused the scrollback buffer to render twice
+
+### More
+- Support custom brand name in Windows PowerShell installer
+- Redesigned Windows registration flow; removed Win10 MSI dependency
+
+## [0.9.18] - 2026-03-28
+
+### Fixed
+- **Brand skill config now reloads from disk on every `load_all`**: brand skills installed or activated after the initial startup were previously invisible until restart — the skill loader now refreshes `BrandConfig` each time it loads skills, so newly installed brand skills take effect immediately
+
+### More
+- Remove `private` keyword from all internal classes to improve Ruby 2.6 compatibility
+- Rename `install.sh` → `install_full.sh`; promote `install_simple.sh` → `install.sh` as the default entry point
+
 ## [0.9.17] - 2026-03-27
 
 ### Added

data/lib/clacky/agent/cost_tracker.rb

@@ -84,7 +84,6 @@ module Clacky
       # Simple approximation: characters / 4 (English text)
 
 
-      private
 
       # Collect token usage data for current iteration and return it.
       # Does NOT call @ui directly — the caller is responsible for displaying

data/lib/clacky/agent/hook_manager.rb

@@ -51,7 +51,6 @@ module Clacky
       end
     end
 
-    private
 
     def validate_event!(event)
       return if HOOK_EVENTS.include?(event)

data/lib/clacky/agent/message_compressor.rb

@@ -108,7 +108,6 @@ module Clacky
       [system_msg, *parsed_messages, *safe_recent].compact
     end
 
-    private
 
     def parse_compressed_result(result, chunk_path: nil)
       # Return the compressed result as a single assistant message

data/lib/clacky/agent/message_compressor_helper.rb

@@ -20,6 +20,14 @@ module Clacky
         @ui&.show_idle_status(phase: :start, message: "Idle detected. Compressing conversation to optimize costs...")
         if compression_context.nil?
           @ui&.show_idle_status(phase: :end, message: "Idle skipped.")
+          Clacky::Logger.info(
+            "Idle compression skipped",
+            enable_compression: @config.enable_compression,
+            previous_total_tokens: @previous_total_tokens,
+            history_size: @history.size,
+            idle_threshold: IDLE_COMPRESSION_THRESHOLD,
+            max_recent_messages: MAX_RECENT_MESSAGES
+          )
           return false
         end
 
@@ -214,7 +222,6 @@ module Clacky
         end
       end
 
-      private
 
       # Returns true if msg is a tool result, regardless of storage format.
       # Canonical: role:"tool"  |  Legacy Anthropic-native: role:"user" + tool_result blocks

data/lib/clacky/agent/session_serializer.rb

@@ -193,7 +193,6 @@ module Clacky
         { has_more: has_more }
       end
 
-      private
 
       # Render a single non-user message into the UI.
       # Used by both the normal round-based replay and the compressed-session fallback.

data/lib/clacky/agent/skill_manager.rb

@@ -258,7 +258,6 @@ module Clacky
         @ui&.show_info("Injected skill content for /#{skill.identifier}")
       end
 
-      private
 
       # Find skills whose identifiers are similar to the given name.
       # Uses substring matching first, then character overlap as a fallback.

data/lib/clacky/brand_config.rb

@@ -862,7 +862,6 @@ module Clacky
       }
     end
 
-    private
 
     def to_yaml
       data = {}

data/lib/clacky/client.rb

@@ -121,7 +121,6 @@ module Clacky
       model_str.match?(/claude(?:-3[-.]?[5-9]|-[4-9]|-sonnet-[34])/)
     end
 
-    private
 
     # ── Bedrock Converse request / response ───────────────────────────────────
 

data/lib/clacky/default_parsers/docx_parser.rb

@@ -1,5 +1,10 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+# encoding: utf-8
+
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+
 #
 # Clacky DOCX Parser — CLI interface
 #
@@ -22,30 +27,43 @@ require "zip"
 require "rexml/document"
 require "stringio"
 
-def read_document_xml(body)
+def safe_utf8(str)
+  # First try force_encoding (lossless, for content that IS valid UTF-8)
+  utf8 = str.dup.force_encoding("UTF-8")
+  return utf8 if utf8.valid_encoding?
+  # Fallback: transcode with replacement for genuinely invalid bytes
+  str.encode("UTF-8", "binary", invalid: :replace, undef: :replace, replace: "")
+end
+
+def read_zip_entry(body, name)
+  xml = nil
   Zip::File.open_buffer(StringIO.new(body)) do |zip|
-    entry = zip.find_entry("word/document.xml")
-    raise "Could not extract content — possibly encrypted or invalid format" unless entry
-    entry.get_input_stream.read
+    entry = zip.find_entry(name)
+    xml = safe_utf8(entry.get_input_stream.read) if entry
   end
+  xml
+end
+
+def read_document_xml(body)
+  xml = read_zip_entry(body, "word/document.xml")
+  raise "Could not extract content — possibly encrypted or invalid format" unless xml
+  xml
 end
 
 def read_numbering(body)
   result = {}
-  Zip::File.open_buffer(StringIO.new(body)) do |zip|
-    entry = zip.find_entry("word/numbering.xml")
-    break unless entry
-    doc = REXML::Document.new(entry.get_input_stream.read)
-    REXML::XPath.each(doc, "//w:abstractNum") do |an|
-      id = an.attributes["w:abstractNumId"]
-      levels = {}
-      REXML::XPath.each(an, "w:lvl") do |lvl|
-        ilvl = lvl.attributes["w:ilvl"].to_i
-        fmt  = REXML::XPath.first(lvl, "w:numFmt")&.attributes&.[]("w:val")
-        levels[ilvl] = { fmt: fmt || "bullet" }
-      end
-      result[id] = levels
+  xml = read_zip_entry(body, "word/numbering.xml")
+  return result unless xml
+  doc = REXML::Document.new(xml)
+  REXML::XPath.each(doc, "//w:abstractNum") do |an|
+    id = an.attributes["w:abstractNumId"]
+    levels = {}
+    REXML::XPath.each(an, "w:lvl") do |lvl|
+      ilvl = lvl.attributes["w:ilvl"].to_i
+      fmt  = REXML::XPath.first(lvl, "w:numFmt")&.attributes&.[]("w:val")
+      levels[ilvl] = { fmt: fmt || "bullet" }
     end
+    result[id] = levels
   end
   result
 rescue
@@ -54,16 +72,14 @@ end
 
 def read_styles(body)
   result = {}
-  Zip::File.open_buffer(StringIO.new(body)) do |zip|
-    entry = zip.find_entry("word/styles.xml")
-    break unless entry
-    doc = REXML::Document.new(entry.get_input_stream.read)
-    REXML::XPath.each(doc, "//w:style") do |s|
-      sid  = s.attributes["w:styleId"]
-      name = REXML::XPath.first(s, "w:name")&.attributes&.[]("w:val").to_s
-      if name =~ /^heading (\d)/i
-        result[sid] = { heading: $1.to_i }
-      end
+  xml = read_zip_entry(body, "word/styles.xml")
+  return result unless xml
+  doc = REXML::Document.new(xml)
+  REXML::XPath.each(doc, "//w:style") do |s|
+    sid  = s.attributes["w:styleId"]
+    name = REXML::XPath.first(s, "w:name")&.attributes&.[]("w:val").to_s
+    if name =~ /^heading (\d)/i
+      result[sid] = { heading: $1.to_i }
     end
   end
   result

data/lib/clacky/default_skills/channel-setup/feishu_setup.rb

@@ -104,7 +104,6 @@ class ToolClient
     raise "ToolClient connection failed: #{e.message}"
   end
 
-  private
 
   def http
     return @http if @http
@@ -286,7 +285,6 @@ class FeishuApiClient
     get_json("#{FEISHU_API_BASE}/app/#{app_id}")
   end
 
-  private
 
   # Execute a GET fetch in the browser page context.
   # Uses window.csrfToken — required by all /developers/v1/ endpoints.

data/lib/clacky/plain_ui_controller.rb

@@ -135,7 +135,6 @@ module Clacky
     def set_input_tips(message, type: :info); end
     def stop; end
 
-    private
 
     def puts_line(text)
       @mutex.synchronize do

data/lib/clacky/server/browser_manager.rb

@@ -190,7 +190,6 @@ module Clacky
     # ---------------------------------------------------------------------------
     # Private
     # ---------------------------------------------------------------------------
-    private
 
     def load_config
       return {} unless File.exist?(BROWSER_CONFIG_PATH)

data/lib/clacky/server/channel/adapters/feishu/adapter.rb

@@ -143,7 +143,6 @@ module Clacky
             errors
           end
 
-          private
 
           # Handle incoming WebSocket event
           # @param raw_event [Hash] Raw event data

data/lib/clacky/server/channel/adapters/feishu/bot.rb

@@ -160,7 +160,6 @@ module Clacky
             end
           end
 
-          private
 
           # Build message content and type based on text content.
           # Uses interactive card (schema 2.0) for code blocks and tables,

data/lib/clacky/server/channel/adapters/feishu/message_parser.rb

@@ -42,7 +42,6 @@ module Clacky
             end
           end
 
-          private
 
           # Parse message.receive event
           # @return [Hash, nil]

data/lib/clacky/server/channel/adapters/feishu/ws_client.rb

@@ -51,7 +51,6 @@ module Clacky
             @ws_socket&.close rescue nil
           end
 
-          private
 
           # Timeout for IO.select on the read loop. Feishu server sends pings every
           # @ping_interval seconds (default 90s). Allow two missed pings before

data/lib/clacky/server/channel/adapters/wecom/adapter.rb

@@ -74,7 +74,6 @@ module Clacky
             errors
           end
 
-          private
 
           def handle_raw_message(raw)
             msgtype = raw["msgtype"]

data/lib/clacky/server/channel/adapters/wecom/ws_client.rb

@@ -115,7 +115,6 @@ module Clacky
             raise
           end
 
-          private
 
           # Timeout for IO.select on the read loop. If no data arrives within this
           # window we treat the connection as dead and reconnect. This catches the

data/lib/clacky/server/channel/adapters/weixin/adapter.rb

@@ -76,6 +76,12 @@ module Clacky
             @context_tokens = {}
             @ctx_mutex      = Mutex.new
             @api_client     = ApiClient.new(base_url: @base_url, token: @token)
+            # Typing keepalive: user_id → { ticket:, thread:, cached_at: }
+            @typing_tickets  = {}
+            @typing_mutex    = Mutex.new
+            # Active keepalive threads: user_id → Thread
+            @keepalive_threads = {}
+            @keepalive_mutex   = Mutex.new
           end
 
           def start(&on_message)
@@ -141,7 +147,7 @@ module Clacky
 
             { message_id: nil }
           rescue => e
-            Clacky::Logger.error("[WeixinAdapter] send_text failed for #{chat_id}: #{e.message}")
+            Clacky::Logger.error("[WeixinAdapter] send_text failed for #{chat_id} (context_token=#{lookup_context_token(chat_id).to_s.slice(0, 20)}...): #{e.message}")
             { message_id: nil }
           end
 
@@ -177,7 +183,6 @@ module Clacky
             false
           end
 
-          private
 
           def process_message(msg)
             # Only process inbound USER messages (message_type 1 = USER)
@@ -355,14 +360,20 @@ module Clacky
             @ctx_mutex.synchronize { @context_tokens[user_id] }
           end
 
-          # Split text into ≤4000-char chunks, preferring newline boundaries.
-          def split_message(text, limit: 4000)
-            return [text] if text.length <= limit
+          # Split text into ≤2000 Unicode character chunks per iLink protocol recommendation.
+          # Priority: split at \n\n, then \n, then space, then hard cut.
+          def split_message(text, limit: 2000)
+            return [text] if text.chars.length <= limit
             chunks = []
-            while text.length > limit
-              cut = text.rindex("\n", limit) || limit
-              chunks << text[0, cut].rstrip
-              text = text[cut..].lstrip
+            while text.chars.length > limit
+              window = text.chars.first(limit).join
+              # Prefer double-newline boundary
+              cut = window.rindex("\n\n")
+              cut = window.rindex("\n")   if cut.nil?
+              cut = window.rindex(" ")    if cut.nil?
+              cut = limit                 if cut.nil? || cut.zero?
+              chunks << text.chars.first(cut).join.rstrip
+              text = text.chars.drop(cut).join.lstrip
             end
             chunks << text unless text.empty?
             chunks
@@ -373,15 +384,102 @@ module Clacky
             r = text.dup
             r.gsub!(/```[^\n]*\n?([\s\S]*?)```/) { Regexp.last_match(1).strip }
             r.gsub!(/!\[[^\]]*\]\([^)]*\)/, "")
-            r.gsub!(/\[([^\]]+)\]\([^)]*\)/, '\1')
-            r.gsub!(/\*\*([^*]+)\*\*/, '\1')
-            r.gsub!(/\*([^*]+)\*/, '\1')
-            r.gsub!(/__([^_]+)__/, '\1')
-            r.gsub!(/_([^_]+)_/, '\1')
+            r.gsub!(/\[([^\]]+)\]\([^)]*\)/, '')
+            r.gsub!(/\*\*([^*]+)\*\*/, '')
+            r.gsub!(/\*([^*]+)\*/, '')
+            r.gsub!(/__([^_]+)__/, '')
+            r.gsub!(/_([^_]+)_/, '')
             r.gsub!(/^#+\s+/, "")
             r.gsub!(/^[-*_]{3,}\s*$/, "")
             r.strip
           end
+
+          # ── Typing keepalive ─────────────────────────────────────────────────
+          # sendtyping(status=1) serves dual purpose: maintains typing indicator AND
+          # renews the context_token TTL. Official @tencent-weixin/openclaw-weixin
+          # npm package uses keepaliveIntervalMs: 5000. We match that exactly.
+          TYPING_KEEPALIVE_INTERVAL = 5
+          # typing_ticket is valid for ~24h; cache and reuse it.
+          TYPING_TICKET_TTL = 86_400
+
+          # Fetch (or return cached) typing_ticket for user_id.
+          # Returns nil on failure — keepalive will just skip without crashing.
+          def fetch_typing_ticket(user_id, context_token)
+            @typing_mutex.synchronize do
+              entry = @typing_tickets[user_id]
+              if entry && (Time.now.to_i - entry[:cached_at]) < TYPING_TICKET_TTL
+                return entry[:ticket]
+              end
+            end
+
+            ticket = @api_client.get_typing_ticket(
+              ilink_user_id: user_id,
+              context_token: context_token
+            )
+            return nil if ticket.empty?
+
+            @typing_mutex.synchronize do
+              @typing_tickets[user_id] = { ticket: ticket, cached_at: Time.now.to_i }
+            end
+            ticket
+          rescue => e
+            Clacky::Logger.warn("[WeixinAdapter] getconfig failed for #{user_id}: #{e.message}")
+            nil
+          end
+
+          # Start a background thread that sends sendtyping(1) every TYPING_KEEPALIVE_INTERVAL.
+          # Any existing keepalive for this user is stopped first.
+          def start_typing_keepalive(user_id, context_token)
+            stop_typing_keepalive(user_id)
+
+            ticket = fetch_typing_ticket(user_id, context_token)
+            unless ticket
+              Clacky::Logger.debug("[WeixinAdapter] no typing_ticket for #{user_id}, skipping keepalive")
+              return
+            end
+
+            thread = Thread.new do
+              loop do
+                begin
+                  @api_client.send_typing(
+                    ilink_user_id: user_id,
+                    typing_ticket: ticket,
+                    status:        1
+                  )
+                  Clacky::Logger.debug("[WeixinAdapter] typing keepalive sent for #{user_id}")
+                rescue => e
+                  Clacky::Logger.debug("[WeixinAdapter] typing keepalive error: #{e.message}")
+                end
+                sleep TYPING_KEEPALIVE_INTERVAL
+              end
+            end
+
+            @keepalive_mutex.synchronize { @keepalive_threads[user_id] = thread }
+            Clacky::Logger.debug("[WeixinAdapter] typing keepalive started for #{user_id}")
+          end
+
+          # Stop keepalive thread and send sendtyping(status=2) to cancel "typing" indicator.
+          def stop_typing_keepalive(user_id)
+            thread = @keepalive_mutex.synchronize { @keepalive_threads.delete(user_id) }
+            return unless thread
+
+            thread.kill
+            thread.join(1)
+
+            ticket = @typing_mutex.synchronize { @typing_tickets.dig(user_id, :ticket) }
+            if ticket
+              begin
+                @api_client.send_typing(
+                  ilink_user_id: user_id,
+                  typing_ticket: ticket,
+                  status:        2
+                )
+              rescue => e
+                Clacky::Logger.debug("[WeixinAdapter] stop typing error: #{e.message}")
+              end
+            end
+            Clacky::Logger.debug("[WeixinAdapter] typing keepalive stopped for #{user_id}")
+          end
         end
 
         Adapters.register(:weixin, Adapter)

data/lib/clacky/server/channel/adapters/weixin/api_client.rb

@@ -61,6 +61,26 @@ module Clacky
             post("getupdates", { get_updates_buf: get_updates_buf }, timeout: LONG_POLL_TIMEOUT_S)
           end
 
+          # Retrieve a typing_ticket for the given user.
+          # context_token is optional but recommended per protocol spec.
+          # @return [String] typing_ticket
+          def get_typing_ticket(ilink_user_id:, context_token: nil)
+            body = { ilink_user_id: ilink_user_id }
+            body[:context_token] = context_token if context_token
+            resp = post("getconfig", body)
+            resp["typing_ticket"].to_s
+          end
+
+          # Send/keep/cancel typing indicator.
+          # @param status [Integer] 1 = typing, 2 = cancel
+          def send_typing(ilink_user_id:, typing_ticket:, status:)
+            post("sendtyping", {
+              ilink_user_id: ilink_user_id,
+              typing_ticket: typing_ticket,
+              status:        status
+            })
+          end
+
           # Send a plain text message.
           # context_token is required by the Weixin protocol for conversation association.
           def send_text(to_user_id:, text:, context_token:)
@@ -173,7 +193,6 @@ module Clacky
             aes_ecb_decrypt(encrypted_bytes, raw_aes_key)
           end
 
-          private
 
           # Full upload pipeline: encrypt → getuploadurl → CDN PUT → return CDNMedia hash.
           def upload_media(raw_bytes:, file_name:, media_type:, to_user_id:)
@@ -354,9 +373,15 @@ module Clacky
             res = http.request(req)
             raise ApiError.new(res.code.to_i, res.body), "HTTP #{res.code}" unless res.is_a?(Net::HTTPSuccess)
 
-            data = JSON.parse(res.body)
+            raw_body = res.body
+            data = JSON.parse(raw_body)
             ret  = data["ret"] || data["errcode"]
-            raise ApiError.new(ret, data["errmsg"]) if ret && ret != 0
+            if ret && ret != 0
+              # Include full response body for easier debugging (errmsg is often empty)
+              detail = data["errmsg"].to_s.strip
+              detail = raw_body.slice(0, 300) if detail.empty?
+              raise ApiError.new(ret, detail)
+            end
 
             data
           rescue Net::ReadTimeout, Net::OpenTimeout

data/lib/clacky/server/channel/channel_manager.rb

@@ -53,7 +53,6 @@ module Clacky
         Clacky::Logger.info("[ChannelManager] Starting channels: #{enabled_platforms.join(", ")}")
         @running = true
         enabled_platforms.each { |platform| start_adapter(platform) }
-        puts "   📱 Channels started: #{enabled_platforms.join(", ")}"
       end
 
       # Stop all adapters gracefully.
@@ -96,7 +95,6 @@ module Clacky
         end
       end
 
-      private
 
       def start_adapter(platform)
         klass = Adapters.find(platform)
@@ -186,11 +184,23 @@ module Clacky
         # source: :channel prevents the message from being echoed back to the IM channel.
         web_ui&.show_user_message(text, source: :channel) unless text.nil? || text.empty?
 
+        # Start typing keepalive BEFORE sending any message.
+        # sendmessage cancels the typing indicator in WeChat protocol,
+        # so keepalive must be running when "Thinking..." is sent so it
+        # immediately re-asserts the typing state after that message.
+        chat_id       = event[:chat_id]
+        context_token = event[:context_token]
+        adapter.start_typing_keepalive(chat_id, context_token) if adapter.respond_to?(:start_typing_keepalive)
+
         # Acknowledge to the IM channel only — WebUI doesn't need a "Thinking..." noise.
-        adapter.send_text(event[:chat_id], "Thinking...")
+        adapter.send_text(chat_id, "Thinking...")
 
         @run_agent_task.call(session_id, agent) do
-          agent.run(text, files: files)
+          begin
+            agent.run(text, files: files)
+          ensure
+            adapter.stop_typing_keepalive(chat_id) if adapter.respond_to?(:stop_typing_keepalive)
+          end
         end
       end
 
@@ -350,7 +360,7 @@ module Clacky
       def safe_stop_adapter(adapter)
         adapter.stop
       rescue StandardError => e
-        warn "[ChannelManager] Error stopping #{adapter.platform_id}: #{e.message}"
+        Clacky::Logger.warn("[ChannelManager] Error stopping #{adapter.platform_id}: #{e.message}")
       end
     end
   end

data/lib/clacky/server/channel/channel_ui_controller.rb

@@ -166,7 +166,6 @@ module Clacky
       def set_input_tips(message, type: :info); end
       def stop; end
 
-      private
 
       def send_text(text)
         text = text.to_s.gsub(/<think>[\s\S]*?<\/think>\n*/i, "").strip