openclacky 1.3.4 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d5879a7f2c6eb0a1846dd3049fa79abd3ca53119750bd0a43b337339f146dad
-  data.tar.gz: 12a39e3d860e9e9e691424289543b73813bcb4652e11fe0719e72aa9e6c72760
+  metadata.gz: 5a7474760c07220891bc62795e95ab0f5b9f83387b4881e1cc9eec4133545222
+  data.tar.gz: '099b846d3a8b44af563403c05f5bc8c855b0925122aabeb3f01b77f8f0c8d18f'
 SHA512:
-  metadata.gz: cdb47cb9da7cccae4329aa0d4b98f03d9e5cadf763c12b9cd255060e2f230154eed3e7404e494f9a0b7e7b54cdb569f2dc25a1ea69c0b8af386a4a1122942d65
-  data.tar.gz: 196c48e418e2119201664b920871aa489ff3531128a8aa8b981f73d6ddc95a7d3ef23ecb79da0611810b8af02735f83340ce0712ddb18ad30de0f94421dbd0a4
+  metadata.gz: e494c9032f35cf631a91dbbff72c89004c1aa8991a6f630dc21c65a9d97b45bceb2afa9c69b2f25b0d4c0e909d317b64eff5ed7b972fd475edc2f19e81a2f779
+  data.tar.gz: 7fb32e090e6cfd780cd0b4218bbfb00a0f939ce77089cc124e35d03a8870abdbb27f09de976304526b8e905d14107fc861914ba08f80d447a72e4d24a6711c8f

data/CHANGELOG.md

@@ -5,6 +5,33 @@ 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.3.5] - 2026-06-29
+
+### Added
+- Run agent inside meeting sessions; launch new meetings directly from session context
+- Long video generation support
+- Show raw LLM error message in error card with collapsible detail
+- Fake tool call detector to catch hallucinated tool invocations
+- Accent color customization for Web UI theme
+
+### Improved
+- Refine auto-confirm wait TUI display
+- Improve split button UX and billing period tab hover behavior
+
+### Fixed
+- Terminal: adaptive GBK/UTF-8 decoding for PTY output to fix garbled text on Windows
+- Resolve vision model detection against the actual request model
+- Fix FrozenError when pressing Ctrl+U to clear text in modal
+- Detect scrollbar-drag correctly to prevent unwanted auto-scroll in chat
+- Fix split button dropdown closing when clicking inside button wrap area
+- Show success toast when saving profile or memory
+- Preserve single line breaks in profile/memory preview
+- Make text selection visible in profile/memory editor
+- Preserve memory card expand state across re-render
+- Refresh time machine on task completion
+- Re-check version on WebSocket reconnect so upgrade badge updates
+- Harden DashScope TTS routing and error handling
+
 ## [1.3.4] - 2026-06-25
 
 ### Added

data/lib/clacky/agent/fake_tool_call_detector.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    module FakeToolCallDetector
+      FAKE_TOOL_CALL_PATTERNS = [
+        /<\s*invoke\s+name\s*=\s*["'][\w\-]+["']/i,
+        /<\s*function_calls\s*>/i,
+        /<\s*tool_use\s*[\s>]/i,
+        /<\s*antml:invoke\s+name\s*=/i,
+        /<\s*antml:function_calls\s*>/i
+      ].freeze
+
+      MAX_FAKE_TOOL_CALL_RETRIES = 2
+
+      private def fake_tool_call_in_content?(content)
+        return false if content.nil? || content.empty?
+        FAKE_TOOL_CALL_PATTERNS.any? { |re| content.match?(re) }
+      end
+
+      private def handle_fake_tool_call(response)
+        @task_fake_tool_call_count = (@task_fake_tool_call_count || 0) + 1
+
+        Clacky::Logger.warn("agent.fake_tool_call_detected",
+          session_id: @session_id,
+          iteration: @iterations,
+          retry_count: @task_fake_tool_call_count,
+          content_head: response[:content].to_s[0, 200],
+          finish_reason: response[:finish_reason].to_s
+        )
+
+        if @task_fake_tool_call_count > MAX_FAKE_TOOL_CALL_RETRIES
+          @ui&.show_error("Model repeatedly emitted text-formatted tool calls instead of using the tool_calls API. Stopping.")
+          emit_assistant_message(response[:content], reasoning_content: response[:reasoning_content]) if response[:content] && !response[:content].empty?
+          return :stop
+        end
+
+        @history.append({ role: "assistant", content: response[:content].to_s })
+        @history.append({
+          role: "user",
+          content: "Your previous reply contained tool-call XML written as text " \
+                   "(e.g. `<invoke name=\"...\">`). That syntax is NOT executed — " \
+                   "it was rendered to the user as raw text. " \
+                   "Re-issue the call using the structured tool_calls field provided by the runtime, " \
+                   "or, if no tool is needed, just answer normally.",
+          system_injected: true
+        })
+        :retry
+      end
+    end
+  end
+end

data/lib/clacky/agent/session_serializer.rb

@@ -153,7 +153,7 @@ module Clacky
       # @param status [Symbol] Status of the last task: :success, :error, or :interrupted
       # @param error_message [String] Error message if status is :error
       # @return [Hash] Session data ready for serialization
-      def to_session_data(status: :success, error_message: nil, updated_at: nil, preserve_updated_at: false)
+      def to_session_data(status: :success, error_message: nil, raw_message: nil, updated_at: nil, preserve_updated_at: false)
         stats_data = {
           total_tasks: @total_tasks,
           total_iterations: @iterations,
@@ -167,7 +167,8 @@ module Clacky
         }
 
         # Add error message if status is error
-        stats_data[:last_error] = error_message if status == :error && error_message
+        stats_data[:last_error]     = error_message if status == :error && error_message
+        stats_data[:last_error_raw] = raw_message   if status == :error && raw_message
 
         {
           session_id: @session_id,

data/lib/clacky/agent/tool_executor.rb

@@ -254,18 +254,6 @@ module Clacky
         }
       end
 
-      # Show countdown before auto-executing in auto_approve mode.
-      # Gives the user time to see what's happening and Ctrl+C to cancel.
-      # @param seconds [Integer] Countdown duration
-      private def auto_approve_countdown(seconds: 10)
-        return unless @ui
-
-        seconds.downto(1) do |remaining|
-          @ui.show_info("  Auto-executing in #{remaining}s... (Ctrl+C to cancel)", prefix_newline: false)
-          sleep 1
-        end
-      end
-
       # Check if a tool is potentially slow and should show progress
       # @param tool_name [String] Name of the tool
       # @param args [Hash] Tool arguments

data/lib/clacky/agent.rb

@@ -5,6 +5,7 @@ require "json"
 require "cgi"
 require "tty-prompt"
 require "set"
+require_relative "null_ui_controller"
 require_relative "utils/arguments_parser"
 require_relative "utils/file_processor"
 require_relative "utils/environment_detector"
@@ -23,6 +24,7 @@ require_relative "agent/memory_updater"
 require_relative "agent/skill_evolution"
 require_relative "agent/skill_reflector"
 require_relative "agent/skill_auto_creator"
+require_relative "agent/fake_tool_call_detector"
 
 module Clacky
   class Agent
@@ -39,6 +41,7 @@ module Clacky
     include SkillEvolution
     include SkillReflector
     include SkillAutoCreator
+    include FakeToolCallDetector
 
     attr_reader :session_id, :name, :history, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
                 :cache_stats, :cost_source, :ui, :skill_loader, :agent_profile,
@@ -274,6 +277,7 @@ module Clacky
       else
         @start_time = Time.now
         @task_truncation_count = 0  # Reset truncation counter for each task
+        @task_fake_tool_call_count = 0  # Reset fake tool-call counter for each task
         @task_timeout_hint_injected = false  # Reset read-timeout hint injection (see LlmCaller)
         @task_upstream_truncation_hint_injected = false  # Reset upstream-truncation hint injection (see LlmCaller)
         @task_cost_source = :estimated  # Reset for new task
@@ -488,6 +492,18 @@ module Clacky
             Clacky::Logger.warn("agent.think_response.log_failed", error: e.message)
           end
 
+          # Detect fake tool-calls written as XML/text in content (model bug
+          # where it emits `<invoke name="...">` instead of using the
+          # structured tool_calls field). Only triggers when tool_calls is
+          # absent — a real call alongside stray XML is not our problem here.
+          if (response[:tool_calls].nil? || response[:tool_calls].empty?) &&
+             fake_tool_call_in_content?(response[:content])
+            case handle_fake_tool_call(response)
+            when :retry then next
+            when :stop then break
+            end
+          end
+
           # Check if done (no more tool calls needed).
           #
           # Defensive rule: we ONLY exit on empty/missing tool_calls.
@@ -949,10 +965,9 @@ module Clacky
         end
 
         # Special handling for request_user_feedback
-        if call[:name] == "request_user_feedback"
-          # In auto_approve mode, give user time to see and cancel before auto-answering
-          auto_approve_countdown(seconds: 10) if @config.permission_mode == :auto_approve
-        else
+        # The interactive countdown (auto_approve) is handled after the tool
+        # executes, once the question itself has been rendered to the user.
+        unless call[:name] == "request_user_feedback"
           @ui&.show_tool_call(call[:name], redact_tool_args(call[:arguments]))
         end
 
@@ -1037,11 +1052,26 @@ module Clacky
             @ui&.show_tool_call(call[:name], call[:arguments])
 
             if @config.permission_mode == :auto_approve
-              # auto_approve means no human is watching (unattended/scheduled tasks).
-              # Inject an auto_reply so the LLM makes a reasonable decision and keeps going.
-              result = result.merge(
-                auto_reply: "No user is available. Please make a reasonable decision based on the context and continue."
-              )
+              # auto_approve means the agent runs unattended by default, but a
+              # human MAY be watching the terminal. Show a short interactive
+              # countdown: if the user steps in, hand control over and wait for
+              # their answer; otherwise auto-decide and keep going.
+              countdown = @ui&.request_feedback_with_countdown(seconds: 10)
+
+              if @ui.nil? || countdown == :timeout
+                result = result.merge(
+                  auto_reply: "No user is available. Please make a reasonable decision based on the context and continue."
+                )
+              elsif countdown.is_a?(String) && !countdown.strip.empty?
+                # User stepped in and typed an answer right away. Route it through
+                # the denied+feedback path so the agent responds to it immediately
+                # instead of breaking and forcing the user to re-type.
+                denied = true
+                feedback = countdown
+              else
+                # User stepped in but gave no text — hand control back to the CLI.
+                awaiting_feedback = true
+              end
             else
               # confirm_all / confirm_safes — a human is present, truly wait for user input.
               awaiting_feedback = true
@@ -1288,6 +1318,41 @@ module Clacky
       @tool_registry.register(Tools::Browser.new)
     end
 
+    # Run a one-off task on a forked subagent and return its final reply text,
+    # WITHOUT mutating this (parent) agent's history. Used by extensions that
+    # need a side analysis (e.g. meeting annotate) which must reuse the parent's
+    # cached context + unified billing, but must NOT pollute the main conversation.
+    #
+    # The subagent deep-clones the parent history (cache prefix + task state), runs
+    # to completion, and is discarded. Only the cost is merged back into the parent.
+    #
+    # @param task [String] The task/prompt for the subagent
+    # @param model [String, nil] Model name ("lite" for the lite companion, nil = current)
+    # @param forbidden_tools [Array<String>] Tool names to block at runtime
+    # @return [String] Subagent's final assistant reply (empty string if none)
+    def run_detached(task, model: nil, forbidden_tools: [])
+      subagent = fork_subagent(
+        model: model,
+        forbidden_tools: forbidden_tools,
+        system_prompt_suffix: "You are running a one-off background analysis. Do the task and return only the requested output. Do not ask follow-up questions."
+      )
+      # Detached runs must stay invisible: a real UI (e.g. WebUIController bound
+      # to the parent's session_id) would broadcast the subagent's raw output
+      # into the parent chat transcript. Swap in a no-op UI so nothing leaks.
+      subagent.instance_variable_set(:@ui, NullUIController.new)
+      parent_count = subagent.instance_variable_get(:@parent_message_count) || 0
+      result = subagent.run(task)
+
+      @total_cost += result[:total_cost_usd] || 0.0
+
+      new_messages = subagent.history.to_a[parent_count..] || []
+      new_messages
+        .reverse
+        .find { |m| m[:role] == "assistant" && m[:content] && !m[:content].to_s.empty? }
+        &.dig(:content)
+        .to_s
+    end
+
     # Fork a subagent with specified configuration
     # The subagent inherits all messages and tools from parent agent
     # Tools are not modified (for cache reuse), but forbidden tools are blocked at runtime via hooks

data/lib/clacky/api_extension.rb

@@ -238,6 +238,87 @@ module Clacky
       @http_server&.instance_variable_get(:@agent_config)
     end
 
+    def registry
+      @http_server&.instance_variable_get(:@registry)
+    end
+
+    # Create a brand-new session and optionally kick off its first task.
+    # Returns the new session_id. When a prompt is given, the task is
+    # submitted immediately (the session starts running); display_message
+    # controls the user-facing bubble shown in place of the raw prompt.
+    def create_session(name: nil, prompt: nil, working_dir: nil, profile: "general",
+                       source: :manual, display_message: nil)
+      error!("server not ready", status: 503) unless @http_server
+
+      session_id = @http_server.send(
+        :build_session,
+        name: name,
+        working_dir: working_dir,
+        profile: profile,
+        source: source
+      )
+
+      submit_task(session_id, prompt, display_message: display_message) if prompt && !prompt.strip.empty?
+
+      session_id
+    end
+
+    # Submit a prompt to an existing session for execution.
+    # The session must be idle; returns the session_id on success.
+    # Raises Halt (409) if the session is already running.
+    def submit_task(session_id, prompt, display_message: nil)
+      reg = registry
+      error!("server not ready", status: 503) unless reg
+
+      unless reg.exist?(session_id)
+        reg.ensure(session_id)
+        error!("session not found: #{session_id}", status: 404) unless reg.exist?(session_id)
+      end
+
+      session = reg.get(session_id)
+      error!("session is busy", status: 409) if session[:status] == :running
+
+      @http_server.send(:run_session_task, session_id, prompt, display_message: display_message)
+      session_id
+    end
+
+    # Run a one-off side task on an existing session's agent and return its
+    # reply text SYNCHRONOUSLY, without polluting the main conversation.
+    #
+    # Unlike submit_task (which enqueues a turn into the live conversation and
+    # returns immediately), this forks the session's agent — reusing its cached
+    # context and unified billing — runs the task to completion on the fork, and
+    # returns the fork's final reply. The main conversation is never touched.
+    #
+    # Strategy A (parent-busy → skip): if the session is currently running, or the
+    # server is at its concurrency limit, this returns { busy: true } without
+    # running. Callers (e.g. periodic analysis) should treat that as "try later".
+    #
+    # @param session_id [String]
+    # @param prompt [String]
+    # @param model [String, nil] "lite" for the lite companion, nil = current
+    # @param forbidden_tools [Array<String>] tool names blocked in the fork
+    # @return [Hash] { text: "..." } on success, or { busy: true } when skipped
+    def dispatch_to_session(session_id, prompt, model: nil, forbidden_tools: [])
+      reg = registry
+      error!("server not ready", status: 503) unless reg
+
+      unless reg.exist?(session_id)
+        reg.ensure(session_id)
+        error!("session not found: #{session_id}", status: 404) unless reg.exist?(session_id)
+      end
+
+      return { busy: true } if reg.respond_to?(:running_full?) && reg.running_full?
+
+      session = reg.get(session_id)
+      return { busy: true } if session[:status] == :running
+
+      agent = session[:agent]
+      error!("session agent not available", status: 503) unless agent
+
+      { text: agent.run_detached(prompt, model: model, forbidden_tools: forbidden_tools) }
+    end
+
     def server_start_time
       @http_server&.instance_variable_get(:@start_time)
     end

data/lib/clacky/api_extension_loader.rb

@@ -12,15 +12,27 @@ module Clacky
   # isolated: skipped with a logged warning, never aborts the load of others.
   module ApiExtensionLoader
     DEFAULT_DIR  = File.expand_path("~/.clacky/api_ext")
+    BUILTIN_DIR  = File.expand_path("../default_extensions", __FILE__)
     DISABLED_DIR = "_disabled"
 
     Result = Struct.new(:loaded, :skipped, keyword_init: true)
 
     class << self
-      def load_all(dir: DEFAULT_DIR)
+      def load_all(dir: DEFAULT_DIR, builtin: true)
         result = Result.new(loaded: [], skipped: [])
         Clacky::ApiExtension.reset_registry!
 
+        # Load built-in (gem-shipped) extensions first (lowest priority)
+        if builtin && Dir.exist?(BUILTIN_DIR)
+          Dir.glob(File.join(BUILTIN_DIR, "*", "handler.rb")).sort.each do |handler_path|
+            ext_dir = File.dirname(handler_path)
+            ext_id  = File.basename(ext_dir)
+            next if ext_id.start_with?("_")
+            load_one(ext_id, ext_dir, handler_path, result)
+          end
+        end
+
+        # Load user extensions (higher priority — same ext_id overwrites built-in)
         if Dir.exist?(dir)
           Dir.glob(File.join(dir, "*", "handler.rb")).sort.each do |handler_path|
             ext_dir = File.dirname(handler_path)

data/lib/clacky/client.rb

@@ -34,11 +34,6 @@ module Clacky
       # some OpenRouter-compatible relays only honour Bearer — send both).
       @provider_id = provider_id
 
-      # Determine vision support once at construction time.
-      # Non-vision models (DeepSeek, Kimi, MiniMax, etc.) reject image_url
-      # content blocks; the conversion layer strips them when this is false.
-      @vision_supported = Providers.supports?(provider_id, :vision, model_name: @model)
-
       # Optional override for Faraday read_timeout (e.g. benchmark calls).
       # nil means use the default (300s for streaming).
       @read_timeout = read_timeout
@@ -343,9 +338,12 @@ module Clacky
       # OpenRouter proxies Claude with the same cache_control field convention as Anthropic direct.
       messages = apply_message_caching(messages) if caching_enabled
 
+      # Vision support is resolved against the request's actual model (which may
+      # differ from @model after a runtime switch or fallback override), so the
+      # conversion layer strips image_url blocks for non-vision models.
       body = MessageFormat::OpenAI.build_request_body(
         messages, model, tools, max_tokens, caching_enabled,
-        vision_supported: @vision_supported,
+        vision_supported: Providers.supports?(@provider_id, :vision, model_name: model),
         reasoning_effort: reasoning_effort
       )
       return send_openai_stream_request(body, on_chunk) if on_chunk
@@ -641,35 +639,34 @@ module Clacky
         raise InsufficientCreditError.new(
           "[LLM] #{I18n.t("llm.error.insufficient_credit")}",
           error_code: "insufficient_credit",
-          provider_id: @provider_id
+          provider_id: @provider_id,
+          raw_message: error_message
         )
       end
 
       case response.status
       when 400
-        # Well-behaved APIs (Anthropic, OpenAI) never put quota/availability issues in 400.
-        # However, some proxy/relay providers do — so we inspect the message first.
-        # Also, Bedrock returns ThrottlingException as 400 instead of 429.
         if error_message.match?(/ThrottlingException|unavailable|quota/i)
           raise RetryableError, "[LLM] #{I18n.t("llm.error.rate_limit_400")}"
         end
 
-        # True bad request — our message was malformed. Roll back history so the
-        # broken message is not replayed on the next user turn.
         raise BadRequestError.new(
           "[LLM] Client request error: #{error_message}",
-          display_message: "[LLM] #{I18n.t("llm.error.bad_request")}"
+          display_message: "[LLM] #{I18n.t("llm.error.bad_request")}",
+          raw_message: error_message
         )
-      when 401 then raise AgentError, "[LLM] #{I18n.t("llm.error.invalid_api_key")}"
+      when 401
+        raise AgentError.new("[LLM] #{I18n.t("llm.error.invalid_api_key")}", raw_message: error_message)
       when 403
         i18n_key = "llm.error.403.#{error_code}"
         translated = I18n.t(i18n_key)
         translated = I18n.t("llm.error.403.default") if translated == i18n_key
-        raise AgentError, "[LLM] #{translated}"
-      when 404 then raise AgentError, "[LLM] #{I18n.t("llm.error.endpoint_not_found")}"
+        raise AgentError.new("[LLM] #{translated}", raw_message: error_message)
+      when 404
+        raise AgentError.new("[LLM] #{I18n.t("llm.error.endpoint_not_found")}", raw_message: error_message)
       when 429 then raise RetryableError, "[LLM] #{I18n.t("llm.error.rate_limit_429")}"
       when 500..599 then raise RetryableError, "[LLM] #{I18n.t("llm.error.server_error", status: response.status)}"
-      else raise AgentError, "[LLM] #{I18n.t("llm.error.unexpected", status: response.status)}"
+      else raise AgentError.new("[LLM] #{I18n.t("llm.error.unexpected", status: response.status)}", raw_message: error_message)
       end
     end
 

data/lib/clacky/default_agents/_panels/time_machine/panel.js

@@ -19,6 +19,25 @@
 (() => {
   if (!window.Clacky || !Clacky.ext) return;
 
+  // The currently mounted panel's state, refreshed on every mount. A single WS
+  // hook (registered once below) reloads it when the active session completes a
+  // task, so new snapshots appear without a manual refresh. Kept as a closure
+  // singleton because WS.onEvent has no unsubscribe and the panel re-mounts on
+  // each session switch.
+  let _activeState = null;
+  let _wsHooked = false;
+
+  function _hookWs() {
+    if (_wsHooked || typeof WS === "undefined") return;
+    _wsHooked = true;
+    WS.onEvent((ev) => {
+      if (ev && ev.type === "complete" && _activeState &&
+          ev.session_id === _activeState.sessionId) {
+        loadHistory(_activeState);
+      }
+    });
+  }
+
   const t = (k, fallback) => {
     const v = (typeof I18n !== "undefined") ? I18n.t(k) : null;
     return (v && v !== k) ? v : fallback;
@@ -630,6 +649,9 @@
     d.mask.onclick = onMaskClick;
     document.addEventListener("keydown", onKey);
 
+    _activeState = state;
+    _hookWs();
+
     loadHistory(state);
     return root;
   }, {

data/lib/clacky/default_agents/base_prompt.md

@@ -9,6 +9,7 @@
 
 - **ALWAYS use `glob` tool to find files — NEVER use shell `find` command for file discovery**
 - **All operations default to the working directory** (shown in session context)
+- **NEVER write tool calls as text** (e.g. `<invoke name=...>`, `<function_calls>`). Use the structured tool_calls field — text won't execute.
 
 ## Response Style