openclacky 0.9.23 → 0.9.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1add81a8b60017ed8ed70e090af57bd68d0dce5670124fab1c13b878e57d21d
-  data.tar.gz: 1607062100acf56326e62d75a2fa0599d4eee61686785fceed1e16578c025c6c
+  metadata.gz: 931a504ff578fcee85cf5d361feeca8b772a0aafe3438c4f27cc7da52573453a
+  data.tar.gz: f1cef39e28c531fef2b2b0fb3cf435ffb05729fdeaae12dadb4e338df073ec1e
 SHA512:
-  metadata.gz: 3d499b6484f327b0cdcdaaba21019c9a5b314ba73910c03fde7d64be880e365dea1d1a5bd82cdf993647b11e5b749cd667567265897b99d4e5f98678651ea464
-  data.tar.gz: f02f3b6317c4971152d055a4b6861d53bf719e8278bc65dd3031a80f718937f93c92add6b589b3c3396589e85d1dca4cf1100a440c65691352b0ab4e273c7f43
+  metadata.gz: 8b8bc2a7dd702beb4570e40264b63b75f170c26dea56a354b20c9afdd1d97fb0ef1e2a8010457170d23823ed6bc82353bbfd390c9ef8f6137ad9bbf73e15ee17
+  data.tar.gz: dc13201eda667f31435309a3664503fd53f1973983e0494f2b29b2ff5c0fca336b9801c265aa18830e1878e0a970237de16ab41833992119d8ea24f2eea66b62

data/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.25] - 2026-04-02
+
+### Added
+- **CSV file upload support**: you can now upload `.csv` files in the Web UI — agent can read and analyse tabular data directly
+- **Browser install tips**: when a browser-dependent command fails, the agent now shows a clear install tip with instructions to set up Chrome/Edge, rather than a cryptic error
+- **Auto-focus on file upload dialog**: the file input field is now auto-focused when the upload dialog opens, improving keyboard UX
+- **Session ID search in Web UI**: you can now search sessions by session ID in addition to session name
+
+### Fixed
+- **WeChat (Weixin) file upload**: fixed a bug where file attachments sent via WeChat were not correctly forwarded to the agent
+- **WeChat without browser**: WeChat channel now works even when no browser tool is configured — falls back gracefully
+- **API message timeout**: fixed a race condition in message compression / session serialisation that could cause API requests to time out mid-conversation
+- **Session chunk replay**: fixed a bug where streaming (chunk-based) messages were incorrectly replayed when restoring a session
+
+### Improved
+- **Shell tool robustness**: `pkill` commands are now scope-limited to prevent accidental process kills; server process cleans up properly when the terminal is closed
+- **Broken pipe handling**: improved error handling in the HTTP server and shell tool to avoid noisy broken-pipe errors on abrupt connection close
+
+### More
+- Updated product-help skill with new session search and CSV upload documentation
+- Updated channel-setup skill with improved WeChat non-browser setup guide
+
+## [0.9.24] - 2026-04-02
+
+### Added
+- **New session list & search in Web UI**: sidebar now shows full session history with real-time search — find any past conversation instantly
+- **Session type indicators**: sessions are labeled by type (chat / agent) so you can see at a glance what kind of interaction it was
+- **Image lightbox**: click any image in the chat to expand it full-screen with a clean overlay viewer
+- **Session history replay for streaming messages**: chunk-based (streaming) messages are now fully replayed when revisiting a past session
+- **Xiaomi AI provider**: added Xiaomi as a supported AI provider
+- **Chinese Bing web search**: web search now uses cn.bing.com for users in China, improving search relevance and reliability
+- **Auto-install system dependencies script**: agent can now automatically install missing system packages (Node, Python, etc.) via a bundled `install_system_deps.sh` script
+- **User message timestamps**: each user message now displays the time it was sent
+
+### Fixed
+- **Bedrock file attachments & partial cost tracking**: fixed file handling and cost accumulation for AWS Bedrock sessions
+- **Session name timestamp**: fixed incorrect timestamp display on session names
+- **New session scroll**: new sessions now correctly scroll to the latest message
+- **Feishu WebSocket client crash**: fixed a nil-reference error that caused the Feishu WS client to crash on reconnect
+
 ## [0.9.23] - 2026-04-01
 
 ### Improved
@@ -17,7 +57,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **CLI -c option model initialization**: fixed a bug where the CLI command with -c option was not passing the model name to the client, causing routing failures for certain providers
 
 ### More
-- Rename provider display name to "ClackyAI" for consistency
+- ClackyAI provider updated to use the latest model name format (abs- prefix)
 
 ## [0.9.22] - 2026-03-31
 

data/lib/clacky/agent/message_compressor_helper.rb

@@ -128,7 +128,11 @@ module Clacky
         original_messages = @history.to_a[0..-2]  # All except the last (compression instruction)
 
         # Archive compressed messages to a chunk MD file before discarding them
-        chunk_index = @compressed_summaries.size + 1
+        # Count existing compressed_summary messages in history to determine the next chunk index.
+        # Using @compressed_summaries.size would reset to 0 on process restart and overwrite existing
+        # chunk files, creating circular chunk references. Counting from history is always accurate.
+        existing_chunk_count = original_messages.count { |m| m[:compressed_summary] }
+        chunk_index = existing_chunk_count + 1
         chunk_path = save_compressed_chunk(
           original_messages,
           compression_context[:recent_messages],
@@ -305,9 +309,11 @@ module Clacky
         return nil unless @session_id && @created_at
 
         # Messages being compressed = original minus system message minus recent messages
+        # Also exclude system-injected scaffolding (session context, memory prompts, etc.)
+        # — these are internal CLI metadata and must not appear in chunk MD or WebUI history.
         recent_set = recent_messages.to_a
         messages_to_archive = original_messages.reject do |m|
-          m[:role] == "system" || recent_set.include?(m)
+          m[:role] == "system" || m[:system_injected] || recent_set.include?(m)
         end
 
         return nil if messages_to_archive.empty?
@@ -374,9 +380,23 @@ module Clacky
             end
             lines << ""
             # Include tool calls summary if present
+            # Format: "_Tool calls: name | {args_json}_" so replay can restore args for WebUI display.
             if msg[:tool_calls]&.any?
-              tool_names = msg[:tool_calls].map { |tc| tc.dig(:function, :name) }.compact.join(", ")
-              lines << "_Tool calls: #{tool_names}_"
+              tc_parts = msg[:tool_calls].map do |tc|
+                name = tc.dig(:function, :name) || tc[:name] || ""
+                next nil if name.empty?
+
+                args_raw = tc.dig(:function, :arguments) || tc[:arguments] || {}
+                args = args_raw.is_a?(String) ? (JSON.parse(args_raw) rescue nil) : args_raw
+                if args.is_a?(Hash) && !args.empty?
+                  # Truncate large string values to keep chunk MD readable
+                  compact = args.transform_values { |v| v.is_a?(String) && v.length > 200 ? v[0..197] + "..." : v }
+                  "#{name} | #{compact.to_json}"
+                else
+                  name
+                end
+              end.compact
+              lines << "_Tool calls: #{tc_parts.join("; ")}_"
               lines << ""
             end
             lines << format_message_content(content) if content

data/lib/clacky/agent/session_serializer.rb

@@ -114,6 +114,7 @@ module Clacky
       # Replay conversation history by calling ui.show_* methods for each message.
       # Supports cursor-based pagination using created_at timestamps on user messages.
       # Each "round" starts at a user message and includes all subsequent assistant/tool messages.
+      # Compressed chunks (chunk_path on assistant messages) are transparently expanded.
       #
       # @param ui [Object] UI interface that responds to show_user_message, show_assistant_message, etc.
       # @param limit [Integer] Maximum number of rounds (user turns) to replay
@@ -147,9 +148,29 @@ module Clacky
             rounds << current_round
           elsif current_round
             current_round[:events] << msg
+          elsif msg[:compressed_summary] && msg[:chunk_path]
+            # Compressed summary sitting before any user rounds — expand it from chunk md
+            chunk_rounds = parse_chunk_md_to_rounds(msg[:chunk_path])
+            rounds.concat(chunk_rounds)
+            # After expanding, treat the last chunk round as the current round so that
+            # any orphaned assistant/tool messages that follow in session.json (belonging
+            # to the same task whose user message was compressed into the chunk) get
+            # appended here instead of being silently discarded.
+            current_round = rounds.last
+          elsif rounds.last
+            # Orphaned non-user message with no current_round yet (e.g. recent_messages
+            # after compression started mid-task with no leading user message).
+            # Attach to the last known round rather than drop silently.
+            rounds.last[:events] << msg
           end
         end
 
+        # Expand any compressed_summary assistant messages sitting inside a round's events.
+        # These occur when compression happened mid-round (rare) — expand them in-place.
+        rounds.each do |round|
+          round[:events].select! { |ev| !ev[:compressed_summary] }
+        end
+
         # Apply before-cursor filter: only rounds whose user message created_at < before
         if before
           rounds = rounds.select { |r| r[:user_msg][:created_at] && r[:user_msg][:created_at] < before }
@@ -193,6 +214,176 @@ module Clacky
         { has_more: has_more }
       end
 
+      # Parse a chunk MD file into an array of rounds compatible with replay_history.
+      # Each round is { user_msg: Hash, events: Array<Hash> }.
+      # Timestamps are synthesised from the chunk's archived_at, spread backwards.
+      # Recursively expands nested chunk references (compressed summary inside a chunk).
+      #
+      # @param chunk_path [String] Path to the chunk md file
+      # @return [Array<Hash>] rounds array (may be empty if file missing/unreadable)
+      private def parse_chunk_md_to_rounds(chunk_path, visited: Set.new)
+        return [] unless chunk_path
+
+        # 1. Try the stored absolute path first (same machine, normal case).
+        # 2. If not found, fall back to basename + SESSIONS_DIR (cross-user / cross-machine).
+        resolved = chunk_path.to_s
+        unless File.exist?(resolved)
+          resolved = File.join(Clacky::SessionManager::SESSIONS_DIR, File.basename(resolved))
+        end
+
+        return [] unless File.exist?(resolved)
+
+        # Guard against circular chunk references (e.g. chunk-3 → chunk-2 → chunk-1 → chunk-9 → … → chunk-3)
+        canonical = File.expand_path(resolved)
+        if visited.include?(canonical)
+          Clacky::Logger.warn("parse_chunk_md_to_rounds: circular reference detected, skipping #{canonical}")
+          return []
+        end
+        visited = visited.dup.add(canonical)
+
+        raw = File.read(resolved)
+
+        # Parse YAML front matter to get archived_at for synthetic timestamps
+        archived_at = nil
+        if raw.start_with?("---")
+          fm_end = raw.index("\n---\n", 4)
+          if fm_end
+            fm_text = raw[4...fm_end]
+            fm_text.each_line do |line|
+              if line.start_with?("archived_at:")
+                archived_at = Time.parse(line.split(":", 2).last.strip) rescue nil
+              end
+            end
+          end
+        end
+        base_time = (archived_at || Time.now).to_f
+        chunk_dir = File.dirname(chunk_path.to_s)
+
+        # Split into sections by ## headings
+        sections = []
+        current_role       = nil
+        current_lines      = []
+        current_nested_chunk = nil  # chunk reference from a Compressed Summary heading
+
+        raw.each_line do |line|
+          stripped = line.chomp
+          if (m = stripped.match(/\A## Assistant \[Compressed Summary — original conversation at: (.+)\]/))
+            # Nested chunk reference — record it, treat as assistant section
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = "assistant"
+            current_lines        = []
+            current_nested_chunk = File.join(chunk_dir, m[1])
+          elsif stripped.match?(/\A## (User|Assistant)/)
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = stripped.match(/\A## (User|Assistant)/)[1].downcase
+            current_lines        = []
+            current_nested_chunk = nil
+          elsif stripped.match?(/\A### Tool Result:/)
+            sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+            current_role         = "tool"
+            current_lines        = []
+            current_nested_chunk = nil
+          else
+            current_lines << line
+          end
+        end
+        sections << { role: current_role, lines: current_lines.dup, nested_chunk: current_nested_chunk } if current_role
+
+        # Remove front-matter / header noise sections (nil role or non-user/assistant/tool)
+        sections.select! { |s| %w[user assistant tool].include?(s[:role]) }
+
+        # Group into rounds: each user section starts a new round
+        rounds        = []
+        current_round = nil
+        round_index   = 0
+
+        sections.each do |sec|
+          text = sec[:lines].join.strip
+
+          # Nested chunk: expand it recursively, prepend before current rounds
+          if sec[:nested_chunk]
+            nested = parse_chunk_md_to_rounds(sec[:nested_chunk], visited: visited)
+            rounds = nested + rounds unless nested.empty?
+            # Also render its summary text as an assistant event in current round if any
+            if current_round && !text.empty?
+              current_round[:events] << { role: "assistant", content: text }
+            end
+            next
+          end
+
+          next if text.empty?
+
+          if sec[:role] == "user"
+            round_index += 1
+            # Synthetic timestamp: spread rounds backwards from archived_at
+            synthetic_ts = base_time - (sections.size - round_index) * 1.0
+            current_round = {
+              user_msg: {
+                role: "user",
+                content: text,
+                created_at: synthetic_ts,
+                _from_chunk: true
+              },
+              events: []
+            }
+            rounds << current_round
+          elsif current_round
+            if sec[:role] == "assistant"
+              # Detect "_Tool calls: ..._" lines — convert to tool_calls events
+              # so _replay_single_message renders them as tool group UI (same as live).
+              #
+              # Formats supported:
+              #   New: "_Tool calls: name | {"arg":"val"}; name2 | {"k":"v"}_"
+              #   Old: "_Tool calls: name1, name2_"  (backward compat)
+              remaining_lines = []
+              pending_tool_entries = []  # [{name:, args:}]
+
+              text.each_line do |line|
+                stripped = line.strip
+                if (m = stripped.match(/\A_Tool calls?:\s*(.+?)_?\z/i))
+                  raw = m[1]
+                  # New format uses ";" as separator between tools (each entry: "name | {json}")
+                  # Old format uses "," with no JSON part.
+                  entries = raw.include?(" | ") ? raw.split(/;\s*/) : raw.split(/,\s*/)
+                  entries.each do |entry|
+                    entry = entry.strip
+                    if (parts = entry.match(/\A(.+?)\s*\|\s*(\{.+\})\z/))
+                      tool_name = parts[1].strip
+                      args = JSON.parse(parts[2]) rescue {}
+                      pending_tool_entries << { name: tool_name, args: args }
+                    else
+                      pending_tool_entries << { name: entry, args: {} }
+                    end
+                  end
+                else
+                  remaining_lines << line
+                end
+              end
+
+              # Flush any plain text
+              plain_text = remaining_lines.join.strip
+              current_round[:events] << { role: "assistant", content: plain_text } unless plain_text.empty?
+
+              # Emit one synthetic tool_calls message per detected tool
+              pending_tool_entries.each do |entry|
+                current_round[:events] << {
+                  role: "assistant",
+                  content: "",
+                  tool_calls: [{ name: entry[:name], arguments: entry[:args] }]
+                }
+              end
+            else
+              current_round[:events] << { role: "tool", content: text }
+            end
+          end
+        end
+
+        rounds
+      rescue => e
+        Clacky::Logger.warn("parse_chunk_md_to_rounds failed for #{chunk_path}: #{e.message}")
+        []
+      end
+
 
       # Render a single non-user message into the UI.
       # Used by both the normal round-based replay and the compressed-session fallback.
@@ -328,12 +519,14 @@ module Clacky
           next unless block[:type] == "image_url"
 
           url = block.dig(:image_url, :url)
-          next unless url && url.start_with?("data:")
+          # image_path is stored at send-time so replay can reconstruct the image from tmp
+          path = block[:image_path]
+
+          next unless url&.start_with?("data:") || path
 
-          # Derive mime_type from the data URL prefix (e.g. "data:image/jpeg;base64,...")
-          mime_type = url[/\Adata:([^;]+);/, 1] || "image/jpeg"
+          mime_type = (url || "")[/\Adata:([^;]+);/, 1] || "image/jpeg"
           ext       = mime_type.split("/").last
-          { name: "image_#{idx + 1}.#{ext}", mime_type: mime_type, data_url: url }
+          { name: "image_#{idx + 1}.#{ext}", mime_type: mime_type, data_url: url, path: path }
         end
       end
     end

data/lib/clacky/agent.rb

@@ -218,7 +218,9 @@ module Clacky
       all_disk_files = disk_files + downgraded
 
       # Format user message — text + inline vision images
-      user_content = format_user_content(user_input, vision_images.map { |v| v[:url] })
+      # Store the tmp path alongside the data_url so the history replay can
+      # reconstruct the image if the base64 was stripped (e.g. after compression).
+      user_content = format_user_content(user_input, vision_images.map { |v| { url: v[:url], path: v[:path] } })
 
       # Parse disk files — agent's responsibility, not the upload layer.
       # process_path runs the parser script and returns a FileRef with preview_path or parse_error.
@@ -1111,15 +1113,25 @@ module Clacky
 
     # Build user message content for LLM.
     # Returns plain String when no vision images; Array of content parts otherwise.
-    private def format_user_content(text, vision_urls)
-      vision_urls ||= []
+    # Build user message content for LLM.
+    # vision_images: Array of String (plain url) OR Hash { url:, path: }
+    # path is stored in the block so history replay can reconstruct the image
+    # from the tmp file when the base64 data_url is no longer available.
+    private def format_user_content(text, vision_images)
+      vision_images ||= []
 
-      return text if vision_urls.empty?
+      return text if vision_images.empty?
 
       content = []
       content << { type: "text", text: text } unless text.nil? || text.empty?
-      vision_urls.each do |url|
-        content << { type: "image_url", image_url: { url: url } }
+      vision_images.each do |img|
+        if img.is_a?(Hash)
+          block = { type: "image_url", image_url: { url: img[:url] } }
+          block[:image_path] = img[:path] if img[:path]
+          content << block
+        else
+          content << { type: "image_url", image_url: { url: img } }
+        end
       end
       content
     end
@@ -1156,7 +1168,8 @@ module Clacky
         "Today is #{Time.now.strftime('%Y-%m-%d, %A')}",
         "Current model: #{current_model}",
         os != :unknown ? "OS: #{Clacky::Utils::EnvironmentDetector.os_label}" : nil,
-        desktop ? "Desktop: #{desktop}" : nil
+        desktop ? "Desktop: #{desktop}" : nil,
+        "Working directory: #{@working_dir}"
       ].compact.join(". ")
 
       content = "[Session context: #{parts}]"

data/lib/clacky/default_skills/channel-setup/SKILL.md

@@ -206,7 +206,7 @@ On success: "✅ WeCom channel configured. WeCom client → Contacts → Smart B
 
 Weixin uses a QR code login — no app_id/app_secret needed. The token from the QR scan is saved directly in `channels.yml`.
 
-#### Step 1 — Fetch QR code and open in browser
+#### Step 1 — Fetch QR code
 
 Run the script in `--fetch-qr` mode to get the QR URL without blocking:
 
@@ -221,17 +221,29 @@ Parse the JSON output:
 
 If the output contains `"error"`, show it and stop.
 
-Tell the user:
-> Opening the WeChat QR code in your browser. Please scan it with WeChat, then confirm in the app.
+#### Step 2 — Show QR code to user (browser or manual fallback)
 
-**Open the QR code page in browser** — build a local URL and navigate to it:
+Build the local QR page URL (include current Unix timestamp as `since` to detect new logins only):
+```
+http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/weixin-qr.html?url=<URL-encoded qrcode_url>&since=<current_unix_timestamp>
+```
 
+**Try browser first** — attempt to open the QR page using the browser tool:
 ```
-http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/weixin-qr.html?url=<URL-encoded qrcode_url>
+browser(action="navigate", url="<qr_page_url>")
 ```
 
-Use the browser tool to open this URL. The page renders a proper scannable QR code image using qrcode.js.
-Do NOT open the raw `qrcode_url` directly — that page shows "请使用微信扫码打开" with no actual QR image.
+**If browser succeeds:** Tell the user:
+> I've opened the WeChat QR code in your browser. Please scan it with WeChat, then confirm in the app.
+
+**If browser fails (not configured or unavailable):** Fall back to manual — tell the user:
+> Please open the following link in your browser to scan the WeChat QR code:
+>
+> `http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/weixin-qr.html?url=<URL-encoded qrcode_url>`
+>
+> Scan the QR code with WeChat, confirm in the app, then reply "done".
+
+The page renders a proper scannable QR code image. Do NOT open the raw `qrcode_url` directly — that page shows "请使用微信扫码打开" with no actual QR image.
 
 #### Step 3 — Wait for scan and save credentials
 
@@ -243,7 +255,11 @@ ruby "SKILL_DIR/weixin_setup.rb" --qrcode-id "$QRCODE_ID"
 
 Where `$QRCODE_ID` is the `qrcode_id` from Step 2's JSON output.
 
-This command blocks until the user scans and confirms in WeChat (up to 5 minutes), then automatically saves the token via `POST /api/channels/weixin`.
+Run this command with `timeout: 60`. If it doesn't succeed, **retry up to 3 times with the same `$QRCODE_ID`** — the QR code stays valid for 5 minutes. Only stop retrying if:
+- Exit code is 0 → success
+- Output contains "expired" → QR expired, offer to restart from Step 1
+- Output contains "timed out" → offer to restart from Step 1
+- 3 retries exhausted → show error and offer to restart from Step 1
 
 Tell the user while waiting:
 > Waiting for you to scan the QR code and confirm in WeChat... (this may take a moment)

data/lib/clacky/default_skills/product-help/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: product-help
-description: 'Use this skill when the user asks about my own features, configuration, or usage — installation, skills, Web UI, CLI, API config, memory, sessions, encryption, white-label, publishing, pricing, or troubleshooting. Do NOT trigger for general coding tasks unrelated to me.'
+description: 'Use this skill when the user asks about my own features, configuration, or usage — installation, skills, Web UI, CLI, API config, memory, sessions, encryption, white-label, publishing, pricing, troubleshooting, or restarting the server. Do NOT trigger for general coding tasks unrelated to me.'
 fork_agent: true
 user-invocable: false
 auto_summarize: true
@@ -90,3 +90,16 @@ web_fetch(url: "<URL>", max_length: 5000)
 - If the fetched page doesn't answer the question, try the next most relevant URL (max 2 fetches)
 - If still no answer, tell the user: "请访问 https://www.openclacky.com/docs 查看完整文档"
 - Keep answers concise — extract what's relevant, don't paste the whole page
+
+## Restarting the server
+
+If the user asks to restart the clacky/openclacky server (e.g. "重启", "restart", "请重启openclacky"):
+
+**Do NOT fetch any docs.** Just return this answer directly:
+
+> To restart the server gracefully (hot restart, zero downtime):
+> ```
+> kill -USR1 $CLACKY_MASTER_PID
+> ```
+> This sends USR1 to the Master process, which spawns a new Worker and gracefully stops the old one.
+> The `$CLACKY_MASTER_PID` environment variable is already set in the current session.

data/lib/clacky/message_format/anthropic.rb

@@ -168,6 +168,8 @@ module Clacky
         #      user message as a cache breakpoint, which invalidates the intended cache boundary
         #      and results in cache misses (cache_read=0) every turn.
         blocks = content_to_blocks(content)
+        # Anthropic rejects messages with an empty content array — use a placeholder text block.
+        blocks = [{ type: "text", text: "..." }] if blocks.empty?
         { role: role, content: blocks }
       end
 
@@ -176,11 +178,17 @@ module Clacky
       private_class_method def self.content_to_blocks(content)
         case content
         when String
+          # Anthropic rejects blank text blocks — skip empty strings
+          return [] if content.empty?
+
           [{ type: "text", text: content }]
         when Array
           content.map { |b| normalize_block(b) }.compact
         else
-          [{ type: "text", text: content.to_s }]
+          str = content.to_s
+          return [] if str.empty?
+
+          [{ type: "text", text: str }]
         end
       end
 
@@ -190,8 +198,12 @@ module Clacky
 
         case block[:type]
         when "text"
+          # Anthropic rejects blank text blocks — drop them instead of sending { type:"text", text:"" }
+          text = block[:text]
+          return nil if text.nil? || text.empty?
+
           # Preserve cache_control if present (placed by Client#apply_message_caching)
-          result = { type: "text", text: block[:text] }
+          result = { type: "text", text: text }
           result[:cache_control] = block[:cache_control] if block[:cache_control]
           result
         when "image_url"

data/lib/clacky/message_format/bedrock.rb

@@ -180,6 +180,8 @@ module Clacky
 
         # regular user/assistant message
         blocks = content_to_blocks(content)
+        # Bedrock rejects messages with an empty content array — use a placeholder text block.
+        blocks = [{ text: "..." }] if blocks.empty?
         { role: role, content: blocks }
       end
 
@@ -187,11 +189,17 @@ module Clacky
       private_class_method def self.content_to_blocks(content)
         case content
         when String
+          # Bedrock rejects blank text blocks — skip empty strings
+          return [] if content.empty?
+
           [{ text: content }]
         when Array
           content.map { |b| normalize_block(b) }.compact
         else
-          [{ text: content.to_s }]
+          str = content.to_s
+          return [] if str.empty?
+
+          [{ text: str }]
         end
       end
 
@@ -201,7 +209,11 @@ module Clacky
 
         case block[:type]
         when "text"
-          { text: block[:text].to_s }
+          # Bedrock rejects blank text blocks — drop them
+          text = block[:text].to_s
+          return nil if text.empty?
+
+          { text: text }
         when "image_url"
           # Bedrock image format — base64 only
           url = block.dig(:image_url, :url) || block[:url]

data/lib/clacky/providers.rb

@@ -59,6 +59,15 @@ module Clacky
           "abs-claude-haiku-4-5"
         ],
         "website_url" => "https://clacky.ai"
+      }.freeze,
+
+      "mimo" => {
+        "name" => "MiMo (Xiaomi)",
+        "base_url" => "https://api.xiaomimimo.com/v1",
+        "api" => "openai-completions",
+        "default_model" => "mimo-v2-pro",
+        "models" => ["mimo-v2-pro", "mimo-v2-omni"],
+        "website_url" => "https://platform.xiaomimimo.com/"
       }.freeze
 
     }.freeze

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

@@ -160,6 +160,12 @@ module Clacky
             @ping_interval = (client_config["PingInterval"] || 90).to_i
 
             url = data.dig("data", "URL")
+            if url.nil? || url.strip.empty?
+              Clacky::Logger.error("[feishu-ws] WebSocket endpoint URL is missing from response. " \
+                                   "Please verify your Feishu App ID and App Secret are correct.")
+              raise "Failed to get WebSocket endpoint: URL is missing (check your Feishu App ID / App Secret)"
+            end
+
             if url =~ /service_id=(\d+)/
               @service_id = $1.to_i
             end