openclacky 0.9.30 → 0.9.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85678c695dcd96512aecef3a290beefa0f08b605a351da12c2db6072d6852147
-  data.tar.gz: 298820c8aabc0a13cb874fa577a5cf12757aa403b804c79d0fa804a5142ecbd0
+  metadata.gz: eb05bb9cc5c24901331584bde84b85b264536fa838001bcf113f41df5a96dbce
+  data.tar.gz: a8bde52bacb92f46a894582ad9b00afa2a325323b464194fbbd744a4cbbddc77
 SHA512:
-  metadata.gz: 1d291319e545f25c169341a14e54aa740d17107e2cd97ce39d9285ba7820ba69e3f10f14c15e26e579bfe71d471023be15a6e7ff225131fd77aeb9b916cbcc79
-  data.tar.gz: f89731bd9fc60ca68def237f4cbda3d998dfa306da9419e24b2c3f2dc6cf91c007a80e8bb658685a85d936dab58f246b55bbed7ead92637f0d2b857e645884af
+  metadata.gz: 3684277987068171be446db5ab6efa3fe33304714d963cd757cc2102477911a13dc2b68f7dec2952d020f1bfd6427d8510469214dcdc8c1e8666995c93ddb098
+  data.tar.gz: 7a84b5fc71f3beb237ed07475bd7a72dac6162c9b519e732e1aba2cafe0af05e3d8f1a4d90e3ec857a084a158113720213a873ea73c997ebb553eea39e61964a

data/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.31] - 2026-04-18
+
+### Added
+- GLM (智谱) model provider support — select GLM models directly from the provider settings
+- Claude Opus 4.7 model option in the built-in provider list
+- Skill Creator UI — create and edit skills from the Web interface with a visual editor
+- Interactive feedback cards — `request_user_feedback` now renders as a styled interactive card in all UIs (Web, UI2, plain), instead of plain text
+- Brand deactivation — white-label brand can now be toggled on/off from the settings page
+- Empty skill placeholder — shows a friendly message when no skills are installed yet
+
+### Improved
+- Shell tool large output handling — when a shell command waits for input or times out with large output, the output is now properly truncated and saved to temp files so the agent can still read the full content
+- Chinese UI translations expanded with new thinkverbose labels
+
+### Fixed
+- Bedrock streaming truncation recovery — when a tool call's arguments are truncated by the API, the broken assistant message is now retracted from history and the agent retries cleanly instead of crashing
+- First session scroll position in the Web UI sidebar
+- Idle status indicator in UI2
+- Channels page spacing and skill creator label alignment in Web UI
+
 ## [0.9.30] - 2026-04-16
 
 ### Added

data/lib/clacky/agent/session_serializer.rb

@@ -414,7 +414,8 @@ module Clacky
                 parts = []
                 parts << "**Context:** #{context.strip}" << "" unless context.strip.empty?
                 parts << "**Question:** #{question.strip}"
-                if options && !options.empty?
+                # Guard: options must be an Array to iterate with each_with_index
+                if options.is_a?(Array) && !options.empty?
                   parts << "" << "**Options:**"
                   options.each_with_index { |opt, i| parts << "  #{i + 1}. #{opt}" }
                 end

data/lib/clacky/agent.rb

@@ -698,11 +698,13 @@ module Clacky
             @ui&.update_todos(@todos.dup)
           end
 
-          # Special handling for request_user_feedback: show directly as message
+          # Special handling for request_user_feedback: emit as interactive feedback card
           if call[:name] == "request_user_feedback"
-            if result.is_a?(Hash) && result[:message]
-              @ui&.show_assistant_message(result[:message], files: [])
-            end
+            # Pass the raw call arguments to show_tool_call so the WebUI controller
+            # can extract question/context/options and emit a "request_feedback" event
+            # (renders as a clickable card in the browser).
+            # Fallback UIs (terminal, IM channels) receive the formatted text message.
+            @ui&.show_tool_call(call[:name], call[:arguments])
 
             if @config.permission_mode == :auto_approve
               # auto_approve means no human is watching (unattended/scheduled tasks).
@@ -734,6 +736,17 @@ module Clacky
           }
           Clacky::Logger.error("tool_execution_error", tool: call[:name], error: e)
 
+          # If arguments were malformed/truncated (e.g. Bedrock streaming truncation),
+          # retract the bad assistant message from history so the next LLM call gets a
+          # fresh context rather than re-reading a cached broken tool call.
+          # Also skip adding a tool_result — without the assistant message there is no
+          # tool_call to pair with, and sending an orphan tool_result breaks the API.
+          if e.is_a?(Utils::BadArgumentsError)
+            size_before = @history.size
+            @history.pop_while { |m| m[:role] == "assistant" && m[:tool_calls]&.any? { |tc| tc[:id] == call[:id] } }
+            next if @history.size < size_before # message was retracted, skip tool_result
+          end
+
           @hooks.trigger(:on_tool_error, call, e)
           @ui&.show_tool_error(e)
           # Use build_denied_result with system_injected=true so LLM knows it can retry

data/lib/clacky/brand_config.rb

@@ -135,6 +135,29 @@ module Clacky
       FileUtils.chmod(0o600, BRAND_FILE)
     end
 
+    # Remove the local license binding and wipe all brand-related fields from disk.
+    # Brand skills installed from this license are also cleared.
+    # Returns { success: true }.
+    def deactivate!
+      clear_brand_skills!
+      FileUtils.rm_f(BRAND_FILE)
+      # Reset all in-memory state so this instance is clean after the call.
+      @product_name           = nil
+      @package_name           = nil
+      @logo_url               = nil
+      @support_contact        = nil
+      @support_qr_url         = nil
+      @theme_color            = nil
+      @homepage_url           = nil
+      @license_key            = nil
+      @license_activated_at   = nil
+      @license_expires_at     = nil
+      @license_last_heartbeat = nil
+      @license_user_id        = nil
+      @device_id              = nil
+      { success: true }
+    end
+
     # Activate the license against the OpenClacky Cloud API using HMAC proof.
     # Returns a result hash: { success: bool, message: String, data: Hash }
     def activate!(license_key)

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

@@ -41,21 +41,21 @@ Example (Chinese):
 ### 2. Ask the user to name the AI (card)
 
 Call `request_user_feedback` to let the user pick or type a name for their AI assistant.
-Offer a few fun suggestions as options, plus a free-text fallback.
+Offer a few fun suggestions as options. The user can also ignore the options and type any name directly.
 
 If `lang == "zh"`, use:
 ```json
 {
-  "question": "先来点有意思的 —— 你想叫我什么名字？可以选一个，也可以直接输入你喜欢的：",
-  "options": ["🐟 摸鱼王", "📚 卷王", "🌟 小天才", "🐱 本喵", "🌅 拾光", "自己输入名字…"]
+  "question": "先来点有意思的 —— 你想叫我什么名字？",
+  "options": ["摸鱼王", "老六", "夜猫子", "话唠", "包打听", "碎碎念", "掌柜的"]
 }
 ```
 
 Otherwise (English):
 ```json
 {
-  "question": "Let's start with something fun — what would you like to call me? Pick one or type your own:",
-  "options": ["✨ Aria", "🤖 Max", "🌙 Luna", "⚡ Zap", "🎯 Ace", "Type your own name…"]
+  "question": "Let's start with something fun — what would you like to call me?",
+  "options": ["Nox", "Sable", "Remy", "Vex", "Pip", "Zola", "Bex"]
 }
 ```
 
@@ -108,7 +108,11 @@ Call `request_user_feedback` again. This is where we learn about the user themse
 If `lang == "zh"`, use:
 ```json
 {
-  "question": "那你呢？随便聊聊自己吧 —— 全部可选，填多少都行：\n• 你的名字（我该怎么称呼你？）\n• 职业\n• 最希望用 AI 做什么\n• 社交 / 作品链接（GitHub、微博、个人网站等）—— 我会读取公开信息来更了解你",
+  "question": "那你呢？随便聊聊自己吧 —— 全部可选，填多少都行：
+- 你的名字（我该怎么称呼你？）
+- 职业
+- 最希望用 AI 做什么
+- 社交 / 作品链接（GitHub、微博、个人网站等）—— 我会读取公开信息来更了解你",
   "options": []
 }
 ```
@@ -116,7 +120,11 @@ If `lang == "zh"`, use:
 Otherwise (English):
 ```json
 {
-  "question": "Now a bit about you — all optional, skip anything you like.\n• Your name (what should I call you?)\n• Occupation\n• What you want to use AI for most\n• Social / portfolio links (GitHub, Twitter/X, personal site…) — I'll read them to learn about you",
+  "question": "Now a bit about you — all optional, skip anything you like.
+- Your name (what should I call you?)
+- Occupation
+- What you want to use AI for most
+- Social / portfolio links (GitHub, Twitter/X, personal site…) — I'll read them to learn about you",
   "options": []
 }
 ```

data/lib/clacky/plain_ui_controller.rb

@@ -23,6 +23,25 @@ module Clacky
 
     def show_tool_call(name, args)
       args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
+
+      # Special handling for request_user_feedback — display as a readable prompt
+      if name.to_s == "request_user_feedback"
+        question = args_data.is_a?(Hash) ? (args_data[:question] || args_data["question"]).to_s : ""
+        context  = args_data.is_a?(Hash) ? (args_data[:context]  || args_data["context"]).to_s  : ""
+        options  = args_data.is_a?(Hash) ? (args_data[:options]  || args_data["options"])        : nil
+        options  = Array(options) if options && !options.is_a?(Array)
+
+        parts = []
+        parts << "**Context:** #{context.strip}" if context && !context.strip.empty?
+        parts << "**Question:** #{question.strip}"
+        if options && !options.empty?
+          parts << "**Options:**"
+          options.each_with_index { |opt, i| parts << "  #{i + 1}. #{opt}" }
+        end
+        puts_line(parts.join("\n"))
+        return
+      end
+
       display = case name
                 when "shell", "safe_shell"
                   cmd = args_data.is_a?(Hash) ? (args_data[:command] || args_data["command"]) : args_data

data/lib/clacky/providers.rb

@@ -18,6 +18,7 @@ module Clacky
         "default_model" => "abs-claude-sonnet-4-5",
         "lite_model" => "abs-claude-haiku-4-5",
         "models" => [
+          "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
           "abs-claude-sonnet-4-6",
           "abs-claude-sonnet-4-5",
@@ -63,7 +64,7 @@ module Clacky
         "base_url" => "https://api.anthropic.com",
         "api" => "anthropic-messages",
         "default_model" => "claude-sonnet-4.6",
-        "models" => ["claude-opus-4-6", "claude-sonnet-4.6", "claude-haiku-4.5"],
+        "models" => ["claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4.6", "claude-haiku-4.5"],
         "website_url" => "https://console.anthropic.com/settings/keys"
       }.freeze,
 
@@ -74,6 +75,7 @@ module Clacky
         "default_model" => "abs-claude-sonnet-4-5",
         "lite_model" => "abs-claude-haiku-4-5",
         "models" => [
+          "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
           "abs-claude-sonnet-4-6",
           "abs-claude-sonnet-4-5",
@@ -94,6 +96,15 @@ module Clacky
         "default_model" => "mimo-v2-pro",
         "models" => ["mimo-v2-pro", "mimo-v2-omni"],
         "website_url" => "https://platform.xiaomimimo.com/"
+      }.freeze,
+
+      "glm" => {
+        "name" => "GLM (ZhipuAI)",
+        "base_url" => "https://open.bigmodel.cn/api/paas/v4",
+        "api" => "openai-completions",
+        "default_model" => "glm-5.1",
+        "models" => ["glm-5.1", "glm-5", "glm-5-turbo", "glm-5v-turbo", "glm-4.7"],
+        "website_url" => "https://open.bigmodel.cn/usercenter/apikeys"
       }.freeze
 
     }.freeze

data/lib/clacky/server/http_server.rb

@@ -281,7 +281,7 @@ module Clacky
 
         server.mount_proc("/") do |req, res|
           if req.path == "/" || req.path == "/index.html"
-            product_name = Clacky::BrandConfig.load.product_name || "Clacky"
+            product_name = Clacky::BrandConfig.load.product_name || "OpenClacky"
             html = File.read(index_html_path).gsub("{{BRAND_NAME}}", product_name)
             res.status                = 200
             res["Content-Type"]       = "text/html; charset=utf-8"
@@ -375,6 +375,7 @@ module Clacky
         when ["GET",    "/api/store/skills"]          then api_store_skills(res)
         when ["GET",    "/api/brand/status"]      then api_brand_status(res)
         when ["POST",   "/api/brand/activate"]    then api_brand_activate(req, res)
+        when ["DELETE", "/api/brand/license"]     then api_brand_deactivate(res)
         when ["GET",    "/api/brand/skills"]      then api_brand_skills(res)
         when ["GET",    "/api/brand"]             then api_brand_info(res)
         when ["GET",    "/api/creator/skills"]    then api_creator_skills(res)
@@ -680,6 +681,17 @@ module Clacky
         end
       end
 
+      # DELETE /api/brand/license
+      # Deactivates (unbinds) the current brand license and clears all brand state.
+      # Brand skills are removed from disk. Returns 200 on success.
+      private def api_brand_deactivate(res)
+        brand  = Clacky::BrandConfig.load
+        result = brand.deactivate!
+        # Reload skill_loader without brand config so brand skills are no longer visible.
+        @skill_loader = Clacky::SkillLoader.new(working_dir: nil, brand_config: Clacky::BrandConfig.new({}))
+        json_response(res, 200, { ok: true })
+      end
+
       # GET /api/brand/skills
       # Fetches the brand skills list from the cloud, enriched with local installed version.
       # Returns 200 with skill list, or 403 when license is not activated.

data/lib/clacky/server/web_ui_controller.rb

@@ -92,11 +92,25 @@ module Clacky
       end
 
       def show_tool_call(name, args)
-        # Skip request_user_feedback — its question is already shown as an assistant message
-        return if name.to_s == "request_user_feedback"
-
         args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
 
+        # Special handling for request_user_feedback — emit a dedicated UI event
+        if name.to_s == "request_user_feedback"
+          question = args_data.is_a?(Hash) ? (args_data[:question] || args_data["question"]).to_s : ""
+          context  = args_data.is_a?(Hash) ? (args_data[:context]  || args_data["context"]).to_s  : ""
+          options  = args_data.is_a?(Hash) ? (args_data[:options]  || args_data["options"])        : nil
+
+          # Normalize options to array (guard against malformed data)
+          options = Array(options) if options && !options.is_a?(Array)
+
+          emit("request_feedback",
+               question: question,
+               context: context,
+               options: options || [])
+          # Don't forward to IM subscribers — they get the formatted text version already
+          return
+        end
+
         # Generate a human-readable summary using the tool's format_call method
         summary = tool_call_summary(name, args_data)
 
@@ -179,13 +193,6 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_info(message) }
       end
 
-      # Emit a two-phase idle compression status update.
-      # The frontend uses the same DOM element for both phases so it renders as one line.
-      # phase: :start → show spinner message; phase: :end → update in-place with final result
-      def show_idle_status(phase:, message:)
-        emit("idle_status", phase: phase.to_s, message: message)
-      end
-
       def show_warning(message)
         emit("warning", message: message)
         forward_to_subscribers { |sub| sub.show_warning(message) }
@@ -209,10 +216,21 @@ module Clacky
       # === Progress ===
 
       def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
-        @progress_start_time = Time.now if phase == "active"
-        @live_progress_message = message
-        # Reset stdout buffer for each new command so re-subscribe only replays current run
-        @live_stdout_buffer = [] if phase == "active"
+        if phase == "active"
+          @progress_start_time = Time.now
+          # Store complete progress state for replay when user switches back to this session
+          @live_progress_state = {
+            message: message,
+            progress_type: progress_type,
+            metadata: metadata
+          }
+          # Reset stdout buffer for each new command so re-subscribe only replays current run
+          @live_stdout_buffer = []
+        elsif phase == "done"
+          # Clear progress state when done
+          @live_progress_state = nil
+          @progress_start_time = nil
+        end
         
         data = {
           message: message,
@@ -225,8 +243,6 @@ module Clacky
         
         emit("progress", **data)
         forward_to_subscribers { |sub| sub.show_progress(message) }
-        
-        @progress_start_time = nil if phase == "done"
       end
 
       # Stream shell stdout/stderr lines to the browser while a command is running.
@@ -264,9 +280,17 @@ module Clacky
       # The frontend's appendToolStdout will attach to the last visible .tool-item
       # even when _liveLastToolItem is null (after the tab re-loaded).
       def replay_live_state
-        return unless @live_progress_message
-
-        emit("progress", message: @live_progress_message, status: "start")
+        return unless @live_progress_state
+
+        # Replay complete progress state (not just message)
+        state = @live_progress_state
+        emit("progress",
+          message: state[:message],
+          progress_type: state[:progress_type],
+          phase: "active",
+          status: "start",
+          metadata: state[:metadata] || {}
+        )
 
         buf = @live_stdout_buffer
         emit("tool_stdout", lines: buf) if buf && !buf.empty?

data/lib/clacky/tools/shell.rb

@@ -397,15 +397,18 @@ module Clacky
       end
 
       def format_waiting_input_result(command, stdout, stderr, interaction, max_output_lines)
+        truncated_stdout = truncate_output(stdout, max_output_lines)
+        truncated_stderr = truncate_output(stderr, max_output_lines)
         {
           command: command,
-          stdout: truncate_output(stdout, max_output_lines),
-          stderr: truncate_output(stderr, max_output_lines),
+          stdout: truncated_stdout,
+          stderr: truncated_stderr,
           exit_code: -2,
           success: false,
           state: 'WAITING_INPUT',
           interaction_type: interaction[:type],
-          message: format_waiting_message(truncate_output(stdout, max_output_lines), interaction),
+          interaction: interaction,
+          message: format_waiting_message(truncated_stdout, interaction),
           output_truncated: output_truncated?(stdout, stderr, max_output_lines)
         }
       end
@@ -441,6 +444,11 @@ module Clacky
         MSG
       end
 
+      def extract_last_line(output)
+        return "" if output.nil? || output.empty?
+        output.lines.last&.strip.to_s[0..200]
+      end
+
       def format_timeout_result(command, stdout, stderr, elapsed, type, timeout, max_output_lines)
         {
           command: command,
@@ -506,32 +514,43 @@ module Clacky
       MAX_LINE_CHARS = 500
 
       def format_result_for_llm(result)
-        return result if result[:error] || result[:state] == 'TIMEOUT' || result[:state] == 'WAITING_INPUT'
+        return result if result[:error]
 
         enc = Clacky::Utils::Encoding
+        command_name = extract_command_name(enc.to_utf8(result[:command].to_s))
+
+        # Apply truncate_and_save to all states including WAITING_INPUT and TIMEOUT
         stdout = enc.to_utf8(result[:stdout] || "")
         stderr = enc.to_utf8(result[:stderr] || "")
-        exit_code = result[:exit_code] || 0
+
+        stdout_info = truncate_and_save(stdout, MAX_LLM_OUTPUT_CHARS, "stdout", command_name)
+        stderr_info = truncate_and_save(stderr, MAX_LLM_OUTPUT_CHARS, "stderr", command_name)
 
         compact = {
           command: enc.to_utf8(result[:command].to_s),
-          exit_code: exit_code,
-          success: result[:success]
+          exit_code: result[:exit_code] || 0,
+          success: result[:success],
+          stdout: stdout_info[:content],
+          stderr: stderr_info[:content]
         }
 
-        compact[:elapsed] = result[:elapsed] if result[:elapsed]
-
-        command_name = extract_command_name(compact[:command])
-
-        stdout_info = truncate_and_save(stdout, MAX_LLM_OUTPUT_CHARS, "stdout", command_name)
-        compact[:stdout] = stdout_info[:content]
         compact[:stdout_full] = stdout_info[:temp_file] if stdout_info[:temp_file]
-
-        stderr_info = truncate_and_save(stderr, MAX_LLM_OUTPUT_CHARS, "stderr", command_name)
-        compact[:stderr] = stderr_info[:content]
         compact[:stderr_full] = stderr_info[:temp_file] if stderr_info[:temp_file]
-
         compact[:output_truncated] = true if result[:output_truncated]
+        compact[:elapsed] = result[:elapsed] if result[:elapsed]
+
+        # Preserve WAITING_INPUT state fields
+        if result[:state] == 'WAITING_INPUT'
+          compact[:state] = 'WAITING_INPUT'
+          compact[:interaction_type] = result[:interaction_type]
+          compact[:message] = format_waiting_message(stdout_info[:content], result[:interaction_type] ? { type: result[:interaction_type], line: result.dig(:interaction, :line) || extract_last_line(stdout_info[:content]) } : { type: 'question', line: extract_last_line(stdout_info[:content]) })
+        end
+
+        # Preserve TIMEOUT state fields
+        if result[:state] == 'TIMEOUT'
+          compact[:state] = 'TIMEOUT'
+          compact[:timeout_type] = result[:timeout_type]
+        end
 
         compact
       end

data/lib/clacky/ui2/ui_controller.rb

@@ -398,6 +398,34 @@ module Clacky
         # doesn't bleed into the next one, and so the buffer is ready before
         # on_output starts firing (which can happen before show_progress is called).
         @stdout_lines = nil
+
+        # Special handling for request_user_feedback: render as a readable interactive card
+        # with the full question and options, rather than the truncated format_call summary.
+        if name.to_s == "request_user_feedback"
+          args_data = args.is_a?(String) ? (JSON.parse(args, symbolize_names: true) rescue {}) : args
+          args_data = args_data.transform_keys(&:to_sym) if args_data.is_a?(Hash)
+
+          question = args_data[:question].to_s.strip
+          context  = args_data[:context].to_s.strip
+          options  = Array(args_data[:options])
+
+          theme = ThemeManager.current_theme
+          parts = []
+
+          parts << context unless context.empty?
+          parts << question unless question.empty?
+
+          if options.any?
+            parts << ""
+            options.each_with_index { |opt, i| parts << "  #{i + 1}. #{opt}" }
+          end
+
+          card_text = parts.join("\n")
+          output = @renderer.render_system_message(card_text, prefix_newline: true)
+          append_output(output)
+          return
+        end
+
         formatted_call = format_tool_call(name, args)
         output = @renderer.render_tool_call(tool_name: name, formatted_call: formatted_call)
         append_output(output)
@@ -466,7 +494,24 @@ module Clacky
       # Show progress indicator with dynamic elapsed time
       # @param message [String] Progress message (optional, will use random thinking verb if nil)
       # @param prefix_newline [Boolean] Whether to add a blank line before progress (default: true)
+      # @param progress_type [String] "thinking" | "idle_compress" | "retrying" | custom
+      # @param phase [String] "active" (start spinner) | "done" (stop spinner, show final message)
+      # @param metadata [Hash] Extensible metadata (unused in UI2 for now)
       def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
+        # phase: "done" → stop any active spinner and render the final message as a system message
+        if phase.to_s == "done"
+          stop_progress_thread
+          @stdout_lines = nil
+          @progress_start_time = nil
+          if message && !message.to_s.strip.empty?
+            output = @renderer.render_system_message(message.to_s, prefix_newline: false)
+            update_progress_line(output)
+          else
+            clear_progress_line
+          end
+          return
+        end
+
         # Stop any existing progress thread
         stop_progress_thread
 
@@ -609,14 +654,6 @@ module Clacky
         append_output(output)
       end
 
-      # Show idle compression status (two-phase: start → end).
-      # In terminal mode, only the final state is printed.
-      def show_idle_status(phase:, message:)
-        return unless phase.to_s == "end"
-        output = @renderer.render_system_message(message)
-        append_output(output)
-      end
-
       # Show warning message
       # @param message [String] Warning message
       def show_warning(message)

data/lib/clacky/utils/arguments_parser.rb

@@ -113,7 +113,7 @@ module Clacky
       def self.raise_helpful_error(call, tool_registry, original_error)
         tool = tool_registry.get(call[:name])
         error_msg = build_error_message(call, tool, original_error)
-        raise StandardError, error_msg
+        raise BadArgumentsError, error_msg
       end
 
       def self.build_error_message(call, tool, original_error)
@@ -173,8 +173,13 @@ module Clacky
       end
     end
 
+    # Raised when tool call arguments are malformed or missing required params.
+    # Distinct from StandardError so the agent can handle it specially
+    # (e.g. retract the bad assistant message from history to break cache loops).
+    class BadArgumentsError < StandardError; end
+
     # Custom exception for missing required parameters
-    class MissingRequiredParamsError < StandardError
+    class MissingRequiredParamsError < BadArgumentsError
       attr_reader :tool_name, :missing_params, :provided_params
 
       def initialize(tool_name, missing_params, provided_params)

data/lib/clacky/version.rb

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