openclacky 1.3.3 → 1.3.5

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,
@@ -252,7 +255,7 @@ module Clacky
       @name = new_name.to_s.strip
     end
 
-    def run(user_input, files: [], display_text: nil)
+    def run(user_input, files: [], display_text: nil, created_at: nil)
       # Show the "thinking" indicator as early as possible so the user gets
       # immediate feedback after sending a message. Without this the UI stays
       # silent during synchronous setup work (system prompt assembly, file
@@ -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
@@ -361,7 +365,8 @@ module Clacky
           preview_path: f[:preview_path] || f["preview_path"] }
       end
 
-      @history.append({ role: "user", content: user_content, task_id: task_id, created_at: Time.now.to_f,
+      created_at ||= Time.now.to_f
+      @history.append({ role: "user", content: user_content, task_id: task_id, created_at: created_at,
                         display_text: display_text,
                         display_files: display_files.empty? ? nil : display_files })
       @total_tasks += 1
@@ -487,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.
@@ -948,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
 
@@ -1036,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
@@ -1287,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/agent_config.rb

@@ -165,8 +165,7 @@ module Clacky
                   :memory_update_enabled, :skill_evolution,
                   :max_running_agents, :max_idle_agents,
                   :default_working_dir,
-                  :proxy_url,
-                  :media_output_dir
+                  :proxy_url
 
     def initialize(options = {})
       @permission_mode = validate_permission_mode(options[:permission_mode])
@@ -224,15 +223,6 @@ module Clacky
       # a proxy. Leave nil to go direct.
       @proxy_url = options[:proxy_url]
 
-      # User-configured directory where generated images / videos / audio
-      # land when a /api/media/* call doesn't pass an explicit output_dir.
-      # Final on-disk path is `<media_output_dir>/assets/generated/<file>`
-      # (the `assets/generated/` suffix is fixed by Media::Base for stable
-      # markdown/relative-path semantics across docs).
-      # Leave nil → fall back to Dir.pwd (legacy behavior, preserved for
-      # older configs that have no key set).
-      @media_output_dir = options[:media_output_dir]
-
       # Per-session virtual model overlay.
       # When set, #current_model returns a *merged* hash (the resolved @models
       # entry merged with this overlay) without mutating the shared @models
@@ -425,7 +415,6 @@ module Clacky
       skill_evolution max_running_agents max_idle_agents
       default_working_dir
       proxy_url
-      media_output_dir
     ].freeze
 
     # Serialize the current agent configuration to YAML.
@@ -445,8 +434,7 @@ module Clacky
         "max_running_agents" => @max_running_agents,
         "max_idle_agents" => @max_idle_agents,
         "default_working_dir" => @default_working_dir,
-        "proxy_url" => @proxy_url,
-        "media_output_dir" => @media_output_dir
+        "proxy_url" => @proxy_url
       }
       YAML.dump("settings" => settings, "models" => persistable_models)
     end

data/lib/clacky/api_extension.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Clacky
+  # Base class for user-defined HTTP API extensions loaded from
+  # ~/.clacky/api_ext/<name>/handler.rb. Subclasses use a tiny route DSL
+  # (get/post/put/patch/delete) to expose endpoints under
+  #   /api/ext/<name>/<sub-path>
+  #
+  # The framework wires up access-key auth, timeouts, JSON error envelopes,
+  # path-parameter parsing, and a curated handler context — extension authors
+  # only fill in business logic.
+  #
+  # Minimal example (~/.clacky/api_ext/my-dashboard/handler.rb):
+  #
+  #   class MyDashboardExt < Clacky::ApiExtension
+  #     get "/summary" do
+  #       json(sessions: session_manager.list.size)
+  #     end
+  #   end
+  #
+  # Mounted automatically at: GET /api/ext/my-dashboard/summary
+  class ApiExtension
+    HTTP_METHODS = %i[get post put patch delete].freeze
+    MAX_TIMEOUT  = 600
+    DEFAULT_TIMEOUT = 10
+
+    Route = Struct.new(:method, :pattern, :regex, :param_names, :block, :options, keyword_init: true)
+
+    class Halt < StandardError
+      attr_reader :status, :payload, :content_type
+
+      def initialize(status, payload, content_type)
+        super("api_ext halt #{status}")
+        @status       = status
+        @payload      = payload
+        @content_type = content_type
+      end
+    end
+
+    class << self
+      # Registry of all loaded ApiExtension subclasses, keyed by extension id
+      # (== directory name == mount prefix segment).
+      def registry
+        @registry ||= {}
+      end
+
+      def register(ext_id, klass)
+        registry[ext_id] = klass
+      end
+
+      def reset_registry!
+        @registry = {}
+        @pending_subclasses = []
+      end
+
+      # Captures every subclass at the moment its `class` body finishes being
+      # required — the loader pops the most recent one off this list to bind
+      # an ext_id/dir without relying on ObjectSpace scans.
+      def pending_subclasses
+        @pending_subclasses ||= []
+      end
+
+      def inherited(subclass)
+        super
+        Clacky::ApiExtension.pending_subclasses << subclass
+      end
+
+      # Per-subclass state — inherited classes carry their own routes/options.
+      def routes
+        @routes ||= []
+      end
+
+      def class_timeout
+        @class_timeout
+      end
+
+      def public_paths
+        @public_paths ||= []
+      end
+
+      def ext_id
+        @ext_id
+      end
+
+      def ext_id=(value)
+        @ext_id = value
+      end
+
+      def ext_dir
+        @ext_dir
+      end
+
+      def ext_dir=(value)
+        @ext_dir = value
+      end
+
+      def meta
+        @meta ||= {}
+      end
+
+      def meta=(value)
+        @meta = value || {}
+      end
+
+      # Set a default timeout (seconds) for every handler in this class.
+      # Per-route override available via `get "/x", timeout: 30 do ... end`.
+      def timeout(seconds)
+        raise ArgumentError, "timeout must be > 0" unless seconds.is_a?(Numeric) && seconds > 0
+        raise ArgumentError, "timeout exceeds MAX_TIMEOUT (#{MAX_TIMEOUT}s)" if seconds > MAX_TIMEOUT
+
+        @class_timeout = seconds.to_f
+      end
+
+      # Mark a route as not requiring access-key auth. Caller must also
+      # declare `public: true` in meta.yml for the framework to honor this.
+      def public_endpoint(pattern)
+        public_paths << normalize_pattern(pattern)
+      end
+
+      HTTP_METHODS.each do |verb|
+        define_method(verb) do |pattern, **opts, &block|
+          raise ArgumentError, "missing handler block for #{verb.upcase} #{pattern}" unless block
+
+          per_route_timeout = opts[:timeout]
+          if per_route_timeout
+            raise ArgumentError, "timeout must be > 0" unless per_route_timeout.is_a?(Numeric) && per_route_timeout > 0
+            raise ArgumentError, "timeout exceeds MAX_TIMEOUT (#{MAX_TIMEOUT}s)" if per_route_timeout > MAX_TIMEOUT
+          end
+
+          normalized = normalize_pattern(pattern)
+          regex, param_names = compile_pattern(normalized)
+          routes << Route.new(
+            method:      verb,
+            pattern:     normalized,
+            regex:       regex,
+            param_names: param_names,
+            block:       block,
+            options:     opts.dup
+          )
+        end
+      end
+
+      def normalize_pattern(pattern)
+        pattern = pattern.to_s
+        pattern = "/#{pattern}" unless pattern.start_with?("/")
+        pattern = pattern.chomp("/")
+        pattern.empty? ? "/" : pattern
+      end
+
+      def compile_pattern(pattern)
+        param_names = []
+        regex_str = pattern.gsub(%r{:([a-zA-Z_][a-zA-Z0-9_]*)}) do |_match|
+          param_names << Regexp.last_match(1).to_sym
+          "([^/]+)"
+        end
+        [Regexp.new("\\A#{regex_str}\\z"), param_names]
+      end
+    end
+
+    attr_reader :req, :res, :route, :params
+
+    def initialize(req:, res:, route:, params:, http_server:)
+      @req         = req
+      @res         = res
+      @route       = route
+      @params      = params
+      @http_server = http_server
+    end
+
+    def invoke
+      instance_exec(&route.block)
+    end
+
+    # ---- handler context (white-listed access to host process) ----
+
+    def json(*args, **kwargs)
+      if args.empty?
+        # Treat kwargs as the body: json(foo: 1, bar: 2)
+        # For non-200 status, pass an explicit hash: json({foo: 1}, status: 422)
+        raise Halt.new(200, JSON.generate(kwargs), "application/json; charset=utf-8")
+      elsif args.size == 1
+        status = kwargs[:status] || 200
+        raise Halt.new(status, JSON.generate(args[0]), "application/json; charset=utf-8")
+      else
+        raise ArgumentError, "json: expected (hash) or (key: value, ...)"
+      end
+    end
+
+    def text(str, status: 200)
+      raise Halt.new(status, str.to_s, "text/plain; charset=utf-8")
+    end
+
+    def error!(message, status: 400, **extra)
+      payload = { error: message.to_s }
+      payload.merge!(extra) unless extra.empty?
+      raise Halt.new(status, JSON.generate(payload), "application/json; charset=utf-8")
+    end
+
+    def json_body
+      @json_body ||= begin
+        return {} if req.body.nil? || req.body.empty?
+        JSON.parse(req.body)
+      rescue JSON::ParserError
+        {}
+      end
+    end
+
+    def query
+      @query ||= req.query || {}
+    end
+
+    def data_path(*parts)
+      base = File.join(self.class.ext_dir, "data")
+      FileUtils.mkdir_p(base)
+      File.join(base, *parts.map(&:to_s))
+    end
+
+    def ext_dir
+      self.class.ext_dir
+    end
+
+    def ext_id
+      self.class.ext_id
+    end
+
+    def config
+      self.class.meta["config"] || {}
+    end
+
+    def session_manager
+      @http_server&.instance_variable_get(:@session_manager)
+    end
+
+    def agent_config
+      @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
+
+    def logger
+      @logger ||= ScopedLogger.new(self.class.ext_id)
+    end
+
+    # Lightweight wrapper that prefixes log lines with the extension id.
+    class ScopedLogger
+      def initialize(ext_id)
+        @prefix = "[api_ext:#{ext_id}]"
+      end
+
+      %i[debug info warn error].each do |level|
+        define_method(level) do |msg|
+          Clacky::Logger.public_send(level, "#{@prefix} #{msg}")
+        end
+      end
+    end
+  end
+end