openclacky 0.5.5 → 0.6.0

data/lib/clacky/agent.rb

@@ -4,12 +4,13 @@ require "securerandom"
 require "json"
 require "tty-prompt"
 require "set"
+require "base64"
 require_relative "utils/arguments_parser"
 
 module Clacky
   class Agent
     attr_reader :session_id, :messages, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
-                :cache_stats, :cost_source
+                :cache_stats, :cost_source, :ui
 
     # System prompt for the coding agent
     SYSTEM_PROMPT = <<~PROMPT.freeze
@@ -50,7 +51,7 @@ module Clacky
       NEVER stop after just adding todos without executing them!
     PROMPT
 
-    def initialize(client, config = {}, working_dir: nil)
+    def initialize(client, config = {}, working_dir: nil, ui: nil)
       @client = client
       @config = config.is_a?(AgentConfig) ? config : AgentConfig.new(config)
       @tool_registry = ToolRegistry.new
@@ -64,7 +65,8 @@ module Clacky
         cache_creation_input_tokens: 0,
         cache_read_input_tokens: 0,
         total_requests: 0,
-        cache_hit_requests: 0
+        cache_hit_requests: 0,
+        raw_api_usage_samples: []  # Store raw API usage for debugging
       }
       @start_time = nil
       @working_dir = working_dir || Dir.pwd
@@ -72,14 +74,18 @@ module Clacky
       @total_tasks = 0
       @cost_source = :estimated  # Track whether cost is from API or estimated
       @task_cost_source = :estimated  # Track cost source for current task
+      @previous_total_tokens = 0  # Track tokens from previous iteration for delta calculation
+      @interrupted = false  # Flag for user interrupt
+      @ui = ui  # UIController for direct UI interaction
+      @debug_logs = []  # Debug logs for troubleshooting
 
       # Register built-in tools
       register_builtin_tools
     end
 
     # Restore from a saved session
-    def self.from_session(client, config, session_data)
-      agent = new(client, config)
+    def self.from_session(client, config, session_data, ui: nil)
+      agent = new(client, config, ui: ui)
       agent.restore_session(session_data)
       agent
     end
@@ -127,27 +133,28 @@ module Clacky
       @hooks.add(event, &block)
     end
 
-    def run(user_input, &block)
+    def run(user_input, images: [])
       @start_time = Time.now
       @task_cost_source = :estimated  # Reset for new task
+      @previous_total_tokens = 0  # Reset token tracking for new task
 
       # Add system prompt as the first message if this is the first run
       if @messages.empty?
         system_prompt = build_system_prompt
         system_message = { role: "system", content: system_prompt }
 
-        # Enable caching for system prompt if configured and model supports it
-        if @config.enable_prompt_caching
-          system_message[:cache_control] = { type: "ephemeral" }
-        end
+        # Note: Don't set cache_control on system prompt
+        # System prompt is usually < 1024 tokens (minimum for caching)
+        # Cache control will be set on tools and conversation history instead
 
         @messages << system_message
       end
 
-      @messages << { role: "user", content: user_input }
+      # Format user message with images if provided
+      user_content = format_user_content(user_input, images)
+      @messages << { role: "user", content: user_content }
       @total_tasks += 1
 
-      emit_event(:on_start, { input: user_input }, &block)
       @hooks.trigger(:on_start, user_input)
 
       begin
@@ -155,30 +162,29 @@ module Clacky
           break if should_stop?
 
           @iterations += 1
-          emit_event(:on_iteration, { iteration: @iterations }, &block)
           @hooks.trigger(:on_iteration, @iterations)
 
           # Think: LLM reasoning with tool support
-          response = think(&block)
+          response = think
 
           # Debug: check for potential infinite loops
           if @config.verbose
-            puts "[DEBUG] Iteration #{@iterations}: finish_reason=#{response[:finish_reason]}, tool_calls=#{response[:tool_calls]&.size || 'nil'}"
+            @ui&.log("Iteration #{@iterations}: finish_reason=#{response[:finish_reason]}, tool_calls=#{response[:tool_calls]&.size || 'nil'}", level: :debug)
           end
 
           # Check if done (no more tool calls needed)
           if response[:finish_reason] == "stop" || response[:tool_calls].nil? || response[:tool_calls].empty?
-            emit_event(:answer, { content: response[:content] }, &block)
+            @ui&.show_assistant_message(response[:content]) if response[:content] && !response[:content].empty?
             break
           end
 
-          # Emit assistant_message event if there's content before tool calls
+          # Show assistant message if there's content before tool calls
           if response[:content] && !response[:content].empty?
-            emit_event(:assistant_message, { content: response[:content] }, &block)
+            @ui&.show_assistant_message(response[:content])
           end
 
           # Act: Execute tool calls
-          action_result = act(response[:tool_calls], &block)
+          action_result = act(response[:tool_calls])
 
           # Observe: Add tool results to conversation context
           observe(response, action_result[:tool_results])
@@ -188,7 +194,6 @@ module Clacky
             # If user provided feedback, treat it as a user question/instruction
             if action_result[:feedback] && !action_result[:feedback].empty?
               # Add user feedback as a new user message
-              # Use a clear format that signals this is important user input
               @messages << {
                 role: "user",
                 content: "STOP. The user has a question/feedback for you: #{action_result[:feedback]}\n\nPlease respond to the user's question/feedback before continuing with any actions."
@@ -197,19 +202,27 @@ module Clacky
               next
             else
               # User just said "no" without feedback - stop and wait
-              emit_event(:answer, { content: "Tool execution was denied. Please provide further instructions." }, &block)
+              @ui&.show_assistant_message("Tool execution was denied. Please provide further instructions.")
               break
             end
           end
         end
 
         result = build_result(:success)
-        emit_event(:on_complete, result, &block)
+        @ui&.show_complete(
+          iterations: result[:iterations],
+          cost: result[:total_cost_usd],
+          duration: result[:duration_seconds],
+          cache_stats: result[:cache_stats]
+        )
         @hooks.trigger(:on_complete, result)
         result
+      rescue Clacky::AgentInterrupted
+        # Let CLI handle the interrupt message
+        raise
       rescue StandardError => e
         result = build_result(:error, error: e.message)
-        emit_event(:on_complete, result, &block)
+        @ui&.show_error("Error: #{e.message}")
         raise
       end
     end
@@ -242,7 +255,8 @@ module Clacky
         total_cost_usd: @total_cost.round(4),
         duration_seconds: @start_time ? (Time.now - @start_time).round(2) : 0,
         last_status: status.to_s,
-        cache_stats: @cache_stats
+        cache_stats: @cache_stats,
+        debug_logs: @debug_logs
       }
 
       # Add error message if status is error
@@ -257,8 +271,6 @@ module Clacky
         config: {
           model: @config.model,
           permission_mode: @config.permission_mode.to_s,
-          max_iterations: @config.max_iterations,
-          max_cost_usd: @config.max_cost_usd,
           enable_compression: @config.enable_compression,
           enable_prompt_caching: @config.enable_prompt_caching,
           keep_recent_messages: @config.keep_recent_messages,
@@ -274,9 +286,6 @@ module Clacky
     private
 
     def should_auto_execute?(tool_name, tool_params = {})
-      # Check if tool is disallowed
-      return false if @config.disallowed_tools.include?(tool_name)
-
       case @config.permission_mode
       when :auto_approve
         true
@@ -362,120 +371,104 @@ module Clacky
       prompt
     end
 
-    def think(&block)
-      emit_event(:thinking, { iteration: @iterations }, &block)
+    def think
+      @ui&.show_progress
 
       # Compress messages if needed to reduce cost
-      compress_messages_if_needed if @config.enable_compression
+      compress_messages_if_needed
 
       # Always send tools definitions to allow multi-step tool calling
-      tools_to_send = @tool_registry.allowed_definitions(@config.allowed_tools)
+      tools_to_send = @tool_registry.all_definitions
 
-      # Show progress indicator while waiting for LLM response
-      progress = ProgressIndicator.new(verbose: @config.verbose)
-      progress.start
+      # Retry logic for network failures
+      max_retries = 10
+      retry_delay = 5
+      retries = 0
 
       begin
-        # Retry logic for network failures
-        max_retries = 10
-        retry_delay = 5
-        retries = 0
-
-        begin
-          response = @client.send_messages_with_tools(
-            @messages,
-            model: @config.model,
-            tools: tools_to_send,
-            max_tokens: @config.max_tokens,
-            verbose: @config.verbose,
-            enable_caching: @config.enable_prompt_caching
-          )
-        rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
-          retries += 1
-          if retries <= max_retries
-            progress.finish
-            puts "\n⚠️  Network request failed: #{e.class.name} - #{e.message}"
-            puts "🔄 Retry #{retries}/#{max_retries}, waiting #{retry_delay} seconds..."
-            sleep retry_delay
-            progress.start
-            retry
-          else
-            progress.finish
-            puts "\n❌ Network request failed after #{max_retries} retries, giving up"
-            raise Error, "Network connection failed after #{max_retries} retries: #{e.message}"
-          end
+        response = @client.send_messages_with_tools(
+          @messages,
+          model: @config.model,
+          tools: tools_to_send,
+          max_tokens: @config.max_tokens,
+          enable_caching: @config.enable_prompt_caching
+        )
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
+        retries += 1
+        if retries <= max_retries
+          @ui&.show_warning("Network failed: #{e.message}. Retry #{retries}/#{max_retries}...")
+          sleep retry_delay
+          retry
+        else
+          @ui&.show_error("Network failed after #{max_retries} retries: #{e.message}")
+          raise Error, "Network connection failed after #{max_retries} retries: #{e.message}"
         end
+      end
 
-        track_cost(response[:usage])
+      # Stop progress thread (but keep progress line visible)
+      @ui&.stop_progress_thread
 
-        # Handle truncated responses (when max_tokens limit is reached)
-        if response[:finish_reason] == "length"
-          # Count recent truncations to prevent infinite loops
-          recent_truncations = @messages.last(5).count { |m|
-            m[:role] == "user" && m[:content]&.include?("[SYSTEM] Your response was truncated")
-          }
+      track_cost(response[:usage], raw_api_usage: response[:raw_api_usage])
 
-          if recent_truncations >= 2
-            # Too many truncations - task is too complex
-            progress.finish
-            puts "\n⚠️  Response truncated multiple times. Task is too complex for a single response." if @config.verbose
-
-            # Create a response that tells the user to break down the task
-            error_response = {
-              content: "I apologize, but this task is too complex to complete in a single response. " \
-                       "Please break it down into smaller steps, or reduce the amount of content to generate at once.\n\n" \
-                       "For example, when creating a long document:\n" \
-                       "1. First create the file with a basic structure\n" \
-                       "2. Then use edit() to add content section by section",
-              finish_reason: "stop",
-              tool_calls: nil
-            }
-
-            # Add this as an assistant message so it appears in conversation
-            @messages << {
-              role: "assistant",
-              content: error_response[:content]
-            }
-
-            return error_response
-          end
+      # Handle truncated responses (when max_tokens limit is reached)
+      if response[:finish_reason] == "length"
+        # Count recent truncations to prevent infinite loops
+        recent_truncations = @messages.last(5).count { |m|
+          m[:role] == "user" && m[:content]&.include?("[SYSTEM] Your response was truncated")
+        }
 
-          # Insert system message to guide LLM to retry with smaller steps
-          @messages << {
-            role: "user",
-            content: "[SYSTEM] Your response was truncated due to length limit. Please retry with a different approach:\n" \
-                     "- For long file content: create the file with structure first, then use edit() to add content section by section\n" \
-                     "- Break down large tasks into multiple smaller steps\n" \
-                     "- Avoid putting more than 2000 characters in a single tool call argument\n" \
-                     "- Use multiple tool calls instead of one large call"
+        if recent_truncations >= 2
+          # Too many truncations - task is too complex
+          @ui&.show_error("Response truncated multiple times. Task is too complex.")
+
+          # Create a response that tells the user to break down the task
+          error_response = {
+            content: "I apologize, but this task is too complex to complete in a single response. " \
+                     "Please break it down into smaller steps, or reduce the amount of content to generate at once.\n\n" \
+                     "For example, when creating a long document:\n" \
+                     "1. First create the file with a basic structure\n" \
+                     "2. Then use edit() to add content section by section",
+            finish_reason: "stop",
+            tool_calls: nil
           }
 
-          puts "⚠️  Response truncated due to length limit. Retrying with smaller steps..." if @config.verbose
+          # Add this as an assistant message so it appears in conversation
+          @messages << {
+            role: "assistant",
+            content: error_response[:content]
+          }
 
-          # Recursively retry
-          return think(&block)
+          return error_response
         end
 
-        # Add assistant response to messages
-        msg = { role: "assistant" }
-        # Always include content field (some APIs require it even with tool_calls)
-        # Use empty string instead of null for better compatibility
-        msg[:content] = response[:content] || ""
-        msg[:tool_calls] = format_tool_calls_for_api(response[:tool_calls]) if response[:tool_calls]
-        @messages << msg
+        # Insert system message to guide LLM to retry with smaller steps
+        @messages << {
+          role: "user",
+          content: "[SYSTEM] Your response was truncated due to length limit. Please retry with a different approach:\n" \
+                   "- For long file content: create the file with structure first, then use edit() to add content section by section\n" \
+                   "- Break down large tasks into multiple smaller steps\n" \
+                   "- Avoid putting more than 2000 characters in a single tool call argument\n" \
+                   "- Use multiple tool calls instead of one large call"
+        }
 
-        if @config.verbose
-          puts "\n[DEBUG] Assistant response added to messages:"
-          puts JSON.pretty_generate(msg)
-        end
+        @ui&.show_warning("Response truncated. Retrying with smaller steps...")
 
-        response
-      ensure
-        progress.finish
+        # Recursively retry
+        return think
       end
+
+      # Add assistant response to messages
+      msg = { role: "assistant" }
+      # Always include content field (some APIs require it even with tool_calls)
+      # Use empty string instead of null for better compatibility
+      msg[:content] = response[:content] || ""
+      msg[:tool_calls] = format_tool_calls_for_api(response[:tool_calls]) if response[:tool_calls]
+      @messages << msg
+
+      response
     end
 
-    def act(tool_calls, &block)
+    def act(tool_calls)
       return { denied: false, feedback: nil, tool_results: [] } unless tool_calls
 
       denied = false
@@ -486,7 +479,7 @@ module Clacky
         # Hook: before_tool_use
         hook_result = @hooks.trigger(:before_tool_use, call)
         if hook_result[:action] == :deny
-          emit_event(:tool_denied, call, &block)
+          @ui&.show_warning("Tool #{call[:name]} denied by hook")
           results << build_error_result(call, hook_result[:reason] || "Tool use denied by hook")
           next
         end
@@ -494,34 +487,32 @@ module Clacky
         # Permission check (if not in auto-approve mode)
         unless should_auto_execute?(call[:name], call[:arguments])
           if @config.is_plan_only?
-            emit_event(:tool_planned, call, &block)
+            @ui&.show_info("Planned: #{call[:name]}")
             results << build_planned_result(call)
             next
           end
 
-          confirmation = confirm_tool_use?(call, &block)
+          confirmation = confirm_tool_use?(call)
           unless confirmation[:approved]
-            emit_event(:tool_denied, call, &block)
+            @ui&.show_warning("Tool #{call[:name]} denied")
             denied = true
             user_feedback = confirmation[:feedback]
             feedback = user_feedback if user_feedback
             results << build_denied_result(call, user_feedback)
 
-            # If user provided feedback, stop processing remaining tools immediately
-            # Let the agent respond to the feedback in the next iteration
-            if user_feedback && !user_feedback.empty?
-              # Fill in denied results for all remaining tool calls to avoid mismatch
-              remaining_calls = tool_calls[(index + 1)..-1] || []
-              remaining_calls.each do |remaining_call|
-                results << build_denied_result(remaining_call, "Auto-denied due to user feedback on previous tool")
-              end
-              break
+            # Auto-deny all remaining tools
+            remaining_calls = tool_calls[(index + 1)..-1] || []
+            remaining_calls.each do |remaining_call|
+              reason = user_feedback && !user_feedback.empty? ?
+                       user_feedback :
+                       "Auto-denied due to user rejection of previous tool"
+              results << build_denied_result(remaining_call, reason)
             end
-            next
+            break
           end
         end
 
-        emit_event(:tool_call, call, &block)
+        @ui&.show_tool_call(call[:name], call[:arguments])
 
         # Execute tool
         begin
@@ -540,11 +531,16 @@ module Clacky
           # Hook: after_tool_use
           @hooks.trigger(:after_tool_use, call, result)
 
-          emit_event(:observation, { tool: call[:name], result: result }, &block)
+          # Update todos display after todo_manager execution
+          if call[:name] == "todo_manager"
+            @ui&.update_todos(@todos.dup)
+          end
+
+          @ui&.show_tool_result(tool.format_result(result))
           results << build_success_result(call, result)
         rescue StandardError => e
           @hooks.trigger(:on_tool_error, call, e)
-          emit_event(:tool_error, { call: call, error: e }, &block)
+          @ui&.show_tool_error(e)
           results << build_error_result(call, e.message)
         end
       end
@@ -589,51 +585,58 @@ module Clacky
       end
     end
 
-    def should_stop?
-      if @iterations >= @config.max_iterations
-        puts "\n⚠️  Reached maximum iterations (#{@config.max_iterations})" if @config.verbose
-        return true
-      end
+    # Interrupt the agent's current run
+    # Called when user presses Ctrl+C during agent execution
+    def interrupt!
+      @interrupted = true
+    end
 
-      if @total_cost >= @config.max_cost_usd
-        puts "\n⚠️  Reached maximum cost ($#{@config.max_cost_usd})" if @config.verbose
-        return true
-      end
+    # Check if agent is currently running
+    def running?
+      @start_time != nil && !should_stop?
+    end
 
-      # Check timeout only if configured (nil means no timeout)
-      if @config.timeout_seconds && Time.now - @start_time > @config.timeout_seconds
-        puts "\n⚠️  Reached timeout (#{@config.timeout_seconds}s)" if @config.verbose
+    def should_stop?
+      if @interrupted
+        @interrupted = false  # Reset for next run
         return true
       end
 
+
       false
     end
 
-    def track_cost(usage)
+    def track_cost(usage, raw_api_usage: nil)
       # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
+      iteration_cost = nil
       if usage[:api_cost]
         @total_cost += usage[:api_cost]
         @cost_source = :api
         @task_cost_source = :api
-        puts "[DEBUG] Using API-provided cost: $#{usage[:api_cost]}" if @config.verbose
+        iteration_cost = usage[:api_cost]
+        @ui&.log("Using API-provided cost: $#{usage[:api_cost]}", level: :debug) if @config.verbose
       else
         # Priority 2: Calculate from tokens using ModelPricing
         result = ModelPricing.calculate_cost(model: @config.model, usage: usage)
         cost = result[:cost]
         pricing_source = result[:source]
-        
+
         @total_cost += cost
+        iteration_cost = cost
         # Map pricing source to cost source: :price or :default
         @cost_source = pricing_source
         @task_cost_source = pricing_source
-        
+
         if @config.verbose
           source_label = pricing_source == :price ? "model pricing" : "default pricing"
-          puts "[DEBUG] Calculated cost for #{@config.model} using #{source_label}: $#{cost.round(6)}"
-          puts "[DEBUG] Usage breakdown: prompt=#{usage[:prompt_tokens]}, completion=#{usage[:completion_tokens]}, cache_write=#{usage[:cache_creation_input_tokens] || 0}, cache_read=#{usage[:cache_read_input_tokens] || 0}"
+          @ui&.log("Calculated cost for #{@config.model} using #{source_label}: $#{cost.round(6)}", level: :debug)
+          @ui&.log("Usage breakdown: prompt=#{usage[:prompt_tokens]}, completion=#{usage[:completion_tokens]}, cache_write=#{usage[:cache_creation_input_tokens] || 0}, cache_read=#{usage[:cache_read_input_tokens] || 0}", level: :debug)
         end
       end
 
+      # Display token usage statistics for this iteration
+      display_iteration_tokens(usage, iteration_cost)
+
       # Track cache usage statistics
       @cache_stats[:total_requests] += 1
 
@@ -645,6 +648,40 @@ module Clacky
         @cache_stats[:cache_read_input_tokens] += usage[:cache_read_input_tokens]
         @cache_stats[:cache_hit_requests] += 1
       end
+
+      # Store raw API usage samples (keep last 3 for debugging)
+      if raw_api_usage
+        @cache_stats[:raw_api_usage_samples] ||= []
+        @cache_stats[:raw_api_usage_samples] << raw_api_usage
+        @cache_stats[:raw_api_usage_samples] = @cache_stats[:raw_api_usage_samples].last(3)
+      end
+    end
+
+    # Display token usage for current iteration
+    private def display_iteration_tokens(usage, cost)
+      prompt_tokens = usage[:prompt_tokens] || 0
+      completion_tokens = usage[:completion_tokens] || 0
+      total_tokens = usage[:total_tokens] || (prompt_tokens + completion_tokens)
+      cache_write = usage[:cache_creation_input_tokens] || 0
+      cache_read = usage[:cache_read_input_tokens] || 0
+
+      # Calculate token delta from previous iteration
+      delta_tokens = total_tokens - @previous_total_tokens
+      @previous_total_tokens = total_tokens  # Update for next iteration
+
+      # Prepare data for UI to format and display
+      token_data = {
+        delta_tokens: delta_tokens,
+        prompt_tokens: prompt_tokens,
+        completion_tokens: completion_tokens,
+        total_tokens: total_tokens,
+        cache_write: cache_write,
+        cache_read: cache_read,
+        cost: cost
+      }
+
+      # Let UI handle formatting and display
+      @ui&.show_token_usage(token_data)
     end
 
     def compress_messages_if_needed
@@ -658,57 +695,30 @@ module Clacky
       original_size = @messages.size
       target_size = @config.keep_recent_messages + 2
 
-      # Show compression progress using ProgressIndicator
-      progress = ProgressIndicator.new(
-        verbose: @config.verbose,
-        message: "🗜️  Compressing conversation history (#{original_size} → ~#{target_size} messages)"
-      )
-      progress.start
+      @ui&.show_info("Compressing history (#{original_size} -> ~#{target_size} messages)...")
 
-      begin
-        # Find the system message (should be first)
-        system_msg = @messages.find { |m| m[:role] == "system" }
-
-        # Get the most recent N messages, ensuring tool_calls/tool results pairs are kept together
-        recent_messages = get_recent_messages_with_tool_pairs(@messages, @config.keep_recent_messages)
+      # Find the system message (should be first)
+      system_msg = @messages.find { |m| m[:role] == "system" }
 
-        # Get messages to compress (everything except system and recent)
-        messages_to_compress = @messages.reject { |m| m[:role] == "system" || recent_messages.include?(m) }
+      # Get the most recent N messages, ensuring tool_calls/tool results pairs are kept together
+      recent_messages = get_recent_messages_with_tool_pairs(@messages, @config.keep_recent_messages)
 
-        if messages_to_compress.empty?
-          progress.finish
-          return
-        end
+      # Get messages to compress (everything except system and recent)
+      messages_to_compress = @messages.reject { |m| m[:role] == "system" || recent_messages.include?(m) }
 
-        # Create summary of compressed messages
-        summary = summarize_messages(messages_to_compress)
+      return if messages_to_compress.empty?
 
-        # Rebuild messages array: [system, summary, recent_messages]
-        # Preserve cache_control on system message if it exists
-        rebuilt_messages = [system_msg, summary, *recent_messages].compact
+      # Create summary of compressed messages
+      summary = summarize_messages(messages_to_compress)
 
-        # Re-apply cache control to system message if caching is enabled
-        if @config.enable_prompt_caching && rebuilt_messages.first&.dig(:role) == "system"
-          rebuilt_messages.first[:cache_control] = { type: "ephemeral" }
-        end
+      # Rebuild messages array: [system, summary, recent_messages]
+      rebuilt_messages = [system_msg, summary, *recent_messages].compact
 
-        @messages = rebuilt_messages
+      @messages = rebuilt_messages
 
-        final_size = @messages.size
+      final_size = @messages.size
 
-        # Finish progress and show completion message
-        progress.finish
-        puts "✅ Compressed conversation history (#{original_size} → #{final_size} messages)"
-
-        # Show detailed summary in verbose mode
-        if @config.verbose
-          puts "\n[COMPRESSION SUMMARY]"
-          puts summary[:content]
-          puts ""
-        end
-      ensure
-        progress.finish
-      end
+      @ui&.show_info("Compressed (#{original_size} -> #{final_size} messages)")
     end
 
     def get_recent_messages_with_tool_pairs(messages, count)
@@ -837,77 +847,46 @@ module Clacky
       }
     end
 
-    def emit_event(type, data, &block)
-      return unless block
-
-      block.call({
-        type: type,
-        data: data,
-        iteration: @iterations,
-        cost: @total_cost
-      })
-    end
-
-    def confirm_tool_use?(call, &block)
-      emit_event(:tool_confirmation_required, call, &block)
-
+    def confirm_tool_use?(call)
       # Show preview first and check for errors
       preview_error = show_tool_preview(call)
 
-      # If preview detected an error (e.g., edit with non-existent string),
-      # auto-deny and provide detailed feedback
+      # If preview detected an error, auto-deny and provide feedback
       if preview_error && preview_error[:error]
-        puts "\nTool call auto-denied due to preview error"
-
-        # Build helpful feedback message
-        feedback = case call[:name]
-        when "edit"
-          "The edit operation will fail because the old_string was not found in the file. " \
-          "Please use file_reader to read '#{preview_error[:path]}' first, " \
-          "find the correct string to replace, and try again with the exact string (including whitespace)."
-        else
-          "Tool preview error: #{preview_error[:error]}"
-        end
-
+        @ui&.show_warning("Tool call auto-denied due to preview error")
+        feedback = build_preview_error_feedback(call[:name], preview_error)
         return { approved: false, feedback: feedback }
       end
 
-      # Then show the confirmation prompt with better formatting
-      prompt_text = format_tool_prompt(call)
-      puts "\n❓ #{prompt_text}"
-
-      # Use TTY::Prompt for better input handling
-      tty_prompt = TTY::Prompt.new(interrupt: :exit)
+      # Request confirmation via UI
+      if @ui
+        prompt_text = format_tool_prompt(call)
+        result = @ui.request_confirmation(prompt_text, default: true)
 
-      begin
-        response = tty_prompt.ask("   (Enter/y to approve, n to deny, or provide feedback):", required: false) do |q|
-          q.modify :strip
+        case result
+        when true
+          { approved: true, feedback: nil }
+        when false, nil
+          { approved: false, feedback: nil }
+        else
+          # String feedback
+          { approved: false, feedback: result.to_s }
         end
-      rescue TTY::Reader::InputInterrupt
-        # Handle Ctrl+C
-        puts
-        return { approved: false, feedback: nil }
-      end
-
-      # Handle nil response (EOF/pipe input)
-      if response.nil? || response.empty?
-        return { approved: true, feedback: nil }  # Empty means approved
-      end
-
-      response_lower = response.downcase
-
-      # "y"/"yes" = approved
-      if response_lower == "y" || response_lower == "yes"
-        return { approved: true, feedback: nil }
+      else
+        # Fallback: auto-approve if no UI
+        { approved: true, feedback: nil }
       end
+    end
 
-      # "n"/"no" = denied without feedback
-      if response_lower == "n" || response_lower == "no"
-        return { approved: false, feedback: nil }
+    private def build_preview_error_feedback(tool_name, error_info)
+      case tool_name
+      when "edit"
+        "The edit operation will fail because the old_string was not found in the file. " \
+        "Please use file_reader to read '#{error_info[:path]}' first, " \
+        "find the correct string to replace, and try again with the exact string (including whitespace)."
+      else
+        "Tool preview error: #{error_info[:error]}"
       end
-
-      # Any other input = denied with feedback
-      { approved: false, feedback: response }
     end
 
     def format_tool_prompt(call)
@@ -947,6 +926,8 @@ module Clacky
     end
 
     def show_tool_preview(call)
+      return nil unless @ui
+
       begin
         args = JSON.parse(call[:arguments], symbolize_names: true)
 
@@ -957,22 +938,22 @@ module Clacky
         when "edit"
           preview_error = show_edit_preview(args)
         when "shell", "safe_shell"
-          preview_error = show_shell_preview(args)
+          show_shell_preview(args)
         else
           # For other tools, show formatted arguments
           tool = @tool_registry.get(call[:name]) rescue nil
           if tool
             formatted = tool.format_call(args) rescue "#{call[:name]}(...)"
-            puts "\nArgs: #{formatted}"
+            @ui&.show_tool_args(formatted)
           else
-            puts "\nArgs: #{call[:arguments]}"
+            @ui&.show_tool_args(call[:arguments])
           end
         end
 
-        return preview_error
+        preview_error
       rescue JSON::ParserError
-        puts "   Args: #{call[:arguments]}"
-        return nil
+        @ui&.show_tool_args(call[:arguments])
+        nil
       end
     end
 
@@ -980,17 +961,16 @@ module Clacky
       path = args[:path] || args['path']
       new_content = args[:content] || args['content'] || ""
 
-      puts "\n📝 File: #{path || '(unknown)'}"
+      is_new_file = !(path && File.exist?(path))
+      @ui&.show_file_write_preview(path, is_new_file: is_new_file)
 
-      if path && File.exist?(path)
-        old_content = File.read(path)
-        puts "Modifying existing file\n"
-        show_diff(old_content, new_content, max_lines: 50)
+      if is_new_file
+        @ui&.show_diff("", new_content, max_lines: 50)
       else
-        puts "Creating new file\n"
-        # Show diff from empty content to new content (all additions)
-        show_diff("", new_content, max_lines: 50)
+        old_content = File.read(path)
+        @ui&.show_diff(old_content, new_content, max_lines: 50)
       end
+      nil
     end
 
     def show_edit_preview(args)
@@ -998,20 +978,20 @@ module Clacky
       old_string = args[:old_string] || args['old_string'] || ""
       new_string = args[:new_string] || args['new_string'] || ""
 
-      puts "\n📝 File: #{path || '(unknown)'}"
+      @ui&.show_file_edit_preview(path)
 
       if !path || path.empty?
-        puts "   ⚠️  No file path provided"
+        @ui&.show_file_error("No file path provided")
         return { error: "No file path provided for edit operation" }
       end
 
       unless File.exist?(path)
-        puts "   ⚠️  File not found: #{path}"
-        return { error: "File not found: #{path}" }
+        @ui&.show_file_error("File not found: #{path}")
+        return { error: "File not found: #{path}", path: path }
       end
 
       if old_string.empty?
-        puts "   ⚠️  No old_string provided (nothing to replace)"
+        @ui&.show_file_error("No old_string provided (nothing to replace)")
         return { error: "No old_string provided (nothing to replace)" }
       end
 
@@ -1019,9 +999,19 @@ module Clacky
 
       # Check if old_string exists in file
       unless file_content.include?(old_string)
-        puts "   ⚠️  String to replace not found in file"
-        puts "   Looking for (first 100 chars):"
-        puts "   #{old_string[0..100].inspect}"
+        # Log debug info for troubleshooting
+        @debug_logs << {
+          timestamp: Time.now.iso8601,
+          event: "edit_preview_failed",
+          path: path,
+          looking_for: old_string[0..500],
+          file_content_preview: file_content[0..1000],
+          file_size: file_content.length
+        }
+
+        @ui&.show_file_error("String to replace not found in file")
+        @ui&.show_file_error("Looking for (first 100 chars):")
+        @ui&.show_file_error(old_string[0..100].inspect)
         return {
           error: "String to replace not found in file",
           path: path,
@@ -1030,34 +1020,31 @@ module Clacky
       end
 
       new_content = file_content.sub(old_string, new_string)
-      show_diff(file_content, new_content, max_lines: 50)
+      @ui&.show_diff(file_content, new_content, max_lines: 50)
       nil  # No error
     end
 
     def show_shell_preview(args)
       command = args[:command] || ""
-      puts "\n💻 Command: #{command}"
+      @ui&.show_shell_preview(command)
+      nil
     end
 
-    def show_diff(old_content, new_content, max_lines: 50)
-      require 'diffy'
-
-      diff = Diffy::Diff.new(old_content, new_content, context: 3)
-      all_lines = diff.to_s(:color).lines
-      display_lines = all_lines.first(max_lines)
+    def build_success_result(call, result)
+      # Try to get tool instance to use its format_result_for_llm method
+      tool = @tool_registry.get(call[:name]) rescue nil
 
-      display_lines.each { |line| puts line.chomp }
-      puts "\n... (#{all_lines.size - max_lines} more lines, diff truncated)" if all_lines.size > max_lines
-    rescue LoadError
-      # Fallback if diffy is not available
-      puts "   Old size: #{old_content.bytesize} bytes"
-      puts "   New size: #{new_content.bytesize} bytes"
-    end
+      formatted_result = if tool && tool.respond_to?(:format_result_for_llm)
+        # Tool provides a custom LLM-friendly format
+        tool.format_result_for_llm(result)
+      else
+        # Fallback: use the original result
+        result
+      end
 
-    def build_success_result(call, result)
       {
         id: call[:id],
-        content: JSON.generate(result)
+        content: JSON.generate(formatted_result)
       }
     end
 
@@ -1133,5 +1120,76 @@ module Clacky
       @tool_registry.register(Tools::TodoManager.new)
       @tool_registry.register(Tools::RunProject.new)
     end
+
+    # Format user content with optional images
+    # @param text [String] User's text input
+    # @param images [Array<String>] Array of image file paths
+    # @return [String|Array] String if no images, Array with text and image_url objects if images present
+    def format_user_content(text, images)
+      return text if images.nil? || images.empty?
+
+      content = []
+      content << { type: "text", text: text } unless text.nil? || text.empty?
+
+      images.each do |image_path|
+        image_url = image_path_to_data_url(image_path)
+        content << { type: "image_url", image_url: { url: image_url } }
+      end
+
+      content
+    end
+
+    # Convert image file path to base64 data URL
+    # @param path [String] File path to image
+    # @return [String] base64 data URL (e.g., "data:image/png;base64,...")
+    def image_path_to_data_url(path)
+      unless File.exist?(path)
+        raise ArgumentError, "Image file not found: #{path}"
+      end
+
+      # Read file as binary
+      image_data = File.binread(path)
+
+      # Detect MIME type from file extension or content
+      mime_type = detect_image_mime_type(path, image_data)
+
+      # Encode to base64
+      base64_data = Base64.strict_encode64(image_data)
+
+      "data:#{mime_type};base64,#{base64_data}"
+    end
+
+    # Detect image MIME type
+    # @param path [String] File path
+    # @param data [String] Binary image data
+    # @return [String] MIME type (e.g., "image/png")
+    def detect_image_mime_type(path, data)
+      # Try to detect from file extension first
+      ext = File.extname(path).downcase
+      case ext
+      when ".png"
+        "image/png"
+      when ".jpg", ".jpeg"
+        "image/jpeg"
+      when ".gif"
+        "image/gif"
+      when ".webp"
+        "image/webp"
+      else
+        # Try to detect from file signature (magic bytes)
+        if data.start_with?("\x89PNG".b)
+          "image/png"
+        elsif data.start_with?("\xFF\xD8\xFF".b)
+          "image/jpeg"
+        elsif data.start_with?("GIF87a".b) || data.start_with?("GIF89a".b)
+          "image/gif"
+        elsif data.start_with?("RIFF".b) && data[8..11] == "WEBP".b
+          "image/webp"
+        else
+          # Default to png if unknown
+          "image/png"
+        end
+      end
+    end
   end
 end