openclacky 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8253fadf5425c27f9b8ebfecfe195c4a21c0f0d944e0c22030dc77411dda41e
-  data.tar.gz: 345301c2cc266afab03564ea08c3801bc1adae239e129d7fc9ac99280e47ec07
+  metadata.gz: 8c1d065edf333a21a538aff43effdcefbc1cb9fa9a3c816d2da3943418f502fb
+  data.tar.gz: d891f1b03ff43bcd237eb510990b74145522404dd4fa3b2bc4b3741f3e495a32
 SHA512:
-  metadata.gz: 2fe927a2d4c86be0ecd45e4defe9ae8646ded14153ac05178bf751a29f108b4ed9744f2e7fd64714437e70e4be1dcc092640154400e9c639deb29d558c42fa0e
-  data.tar.gz: 25f7e33a14d03a1a03e5a0947dab559a5e27244cd7333342bd1014033cce6fac141ae3794eb0fc6dd435260045a695c161bbe07f39f0a253974939cda048edb9
+  metadata.gz: 5190473333b6c0259ee7ec76bf3127986b03fcbbaeba8face1e0f5bd5ebc60d40b9937df7ef129737eb6364789a214a515970728cfd71b80770cc671e5440004
+  data.tar.gz: 0a7858fe351e34810bca0b28ab91b3974041758608fe8c446e6f0c555402c990418bb6d3bc4ac071fe61fe3d881a5c190f191258287541b57508a940c2643752

data/.clackyrules

@@ -22,7 +22,9 @@ It provides chat functionality and autonomous AI agent capabilities with tool us
 - Use frozen string literals: `# frozen_string_literal: true`
 - Keep classes focused and single-responsibility
 - Use meaningful variable and method names
+- **IMPORTANT**: All code comments must be written in English
 - Add descriptive comments for complex logic
+- Use clear, self-documenting code with English naming
 
 ### Architecture Patterns
 - Tools inherit from `Clacky::Tools::Base`

data/README.md

@@ -12,6 +12,7 @@ A command-line interface for interacting with AI models. OpenClacky supports Ope
 - 🎨 Colorful terminal output
 - 🌐 OpenAI-compatible API support (OpenAI, Gitee AI, DeepSeek, etc.)
 - 🛠️ Rich built-in tools: file operations, web search, code execution, and more
+- ⚡ Prompt caching support for Claude models (reduces costs up to 90%)
 
 ## Installation
 

data/lib/clacky/agent.rb

@@ -8,7 +8,8 @@ require_relative "utils/arguments_parser"
 
 module Clacky
   class Agent
-    attr_reader :session_id, :messages, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos
+    attr_reader :session_id, :messages, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
+                :cache_stats
 
     # Pricing per 1M tokens (approximate - adjust based on actual model)
     PRICING = {
@@ -65,6 +66,12 @@ module Clacky
       @todos = []  # Store todos in memory
       @iterations = 0
       @total_cost = 0.0
+      @cache_stats = {
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+        total_requests: 0,
+        cache_hit_requests: 0
+      }
       @start_time = nil
       @working_dir = working_dir || Dir.pwd
       @created_at = Time.now.iso8601
@@ -90,6 +97,14 @@ module Clacky
       @working_dir = session_data[:working_dir]
       @created_at = session_data[:created_at]
       @total_tasks = session_data.dig(:stats, :total_tasks) || 0
+      
+      # Restore cache statistics if available
+      @cache_stats = session_data.dig(:stats, :cache_stats) || {
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+        total_requests: 0,
+        cache_hit_requests: 0
+      }
 
       # Check if the session ended with an error
       last_status = session_data.dig(:stats, :last_status)
@@ -103,7 +118,7 @@ module Clacky
           @messages = @messages[0...last_user_index]
 
           # Trigger a hook to notify about the rollback
-          trigger_hook(:session_rollback, {
+          @hooks.trigger(:session_rollback, {
             reason: "Previous session ended with error",
             error_message: last_error,
             rolled_back_message_index: last_user_index
@@ -122,7 +137,14 @@ module Clacky
       # Add system prompt as the first message if this is the first run
       if @messages.empty?
         system_prompt = build_system_prompt
-        @messages << { role: "system", content: 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
+        
+        @messages << system_message
       end
 
       @messages << { role: "user", content: user_input }
@@ -222,7 +244,8 @@ module Clacky
         total_iterations: @iterations,
         total_cost_usd: @total_cost.round(4),
         duration_seconds: @start_time ? (Time.now - @start_time).round(2) : 0,
-        last_status: status.to_s
+        last_status: status.to_s,
+        cache_stats: @cache_stats
       }
 
       # Add error message if status is error
@@ -240,6 +263,7 @@ module Clacky
           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,
           max_tokens: @config.max_tokens,
           verbose: @config.verbose
@@ -366,7 +390,8 @@ module Clacky
             model: @config.model,
             tools: tools_to_send,
             max_tokens: @config.max_tokens,
-            verbose: @config.verbose
+            verbose: @config.verbose,
+            enable_caching: @config.enable_prompt_caching
           )
         rescue Faraday::ConnectionFailed, Faraday::TimeoutError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
           retries += 1
@@ -386,6 +411,54 @@ module Clacky
 
         track_cost(response[:usage])
 
+        # 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")
+          }
+
+          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
+
+          # 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"
+          }
+
+          puts "⚠️  Response truncated due to length limit. Retrying with smaller steps..." if @config.verbose
+
+          # Recursively retry
+          return think(&block)
+        end
+
         # Add assistant response to messages
         msg = { role: "assistant" }
         # Always include content field (some APIs require it even with tool_calls)
@@ -543,6 +616,18 @@ module Clacky
       input_cost = (usage[:prompt_tokens] / 1_000_000.0) * PRICING[:input]
       output_cost = (usage[:completion_tokens] / 1_000_000.0) * PRICING[:output]
       @total_cost += input_cost + output_cost
+      
+      # Track cache usage statistics
+      @cache_stats[:total_requests] += 1
+      
+      if usage[:cache_creation_input_tokens]
+        @cache_stats[:cache_creation_input_tokens] += usage[:cache_creation_input_tokens]
+      end
+      
+      if usage[:cache_read_input_tokens]
+        @cache_stats[:cache_read_input_tokens] += usage[:cache_read_input_tokens]
+        @cache_stats[:cache_hit_requests] += 1
+      end
     end
 
     def compress_messages_if_needed
@@ -582,7 +667,15 @@ module Clacky
         summary = summarize_messages(messages_to_compress)
 
         # Rebuild messages array: [system, summary, recent_messages]
-        @messages = [system_msg, summary, *recent_messages].compact
+        # Preserve cache_control on system message if it exists
+        rebuilt_messages = [system_msg, summary, *recent_messages].compact
+        
+        # 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
+        
+        @messages = rebuilt_messages
 
         final_size = @messages.size
 
@@ -978,6 +1071,7 @@ module Clacky
         iterations: @iterations,
         duration_seconds: Time.now - @start_time,
         total_cost_usd: @total_cost.round(4),
+        cache_stats: @cache_stats,
         messages: @messages,
         error: error
       }

data/lib/clacky/agent_config.rb

@@ -7,7 +7,8 @@ module Clacky
 
     attr_accessor :model, :max_iterations, :max_cost_usd, :timeout_seconds,
                   :permission_mode, :allowed_tools, :disallowed_tools,
-                  :max_tokens, :verbose, :enable_compression, :keep_recent_messages
+                  :max_tokens, :verbose, :enable_compression, :keep_recent_messages,
+                  :enable_prompt_caching
 
     def initialize(options = {})
       @model = options[:model] || "gpt-3.5-turbo"
@@ -21,6 +22,8 @@ module Clacky
       @verbose = options[:verbose] || false
       @enable_compression = options[:enable_compression].nil? ? true : options[:enable_compression]
       @keep_recent_messages = options[:keep_recent_messages] || 20
+      # Enable prompt caching by default for cost savings
+      @enable_prompt_caching = options[:enable_prompt_caching].nil? ? true : options[:enable_prompt_caching]
     end
 
 

data/lib/clacky/cli.rb

@@ -4,6 +4,10 @@ require "thor"
 require "tty-prompt"
 require "tty-spinner"
 require "readline"
+require_relative "ui/banner"
+require_relative "ui/prompt"
+require_relative "ui/statusbar"
+require_relative "ui/formatter"
 
 module Clacky
   class CLI < Thor
@@ -140,7 +144,7 @@ module Clacky
         # Report the error
         say "\n❌ Error: #{e.message}", :red
         say e.backtrace.first(5).join("\n"), :red if options[:verbose]
-        
+
         # Show session saved message
         if session_manager&.last_saved_path
           say "\n📂 Session saved: #{session_manager.last_saved_path}", :yellow
@@ -149,7 +153,7 @@ module Clacky
         # Guide user to recover
         say "\n💡 To recover and retry, run:", :yellow
         say "   clacky agent -c", :cyan
-        
+
         exit 1
       ensure
         Dir.chdir(original_dir)
@@ -214,12 +218,14 @@ module Clacky
       end
 
       def display_agent_event(event)
+        formatter = ui_formatter
+
         case event[:type]
         when :thinking
-          print "💭 "
+          formatter.thinking
         when :assistant_message
           # Display assistant's thinking/explanation before tool calls
-          say "\n💬 #{event[:data][:content]}", :white if event[:data][:content] && !event[:data][:content].empty?
+          formatter.assistant_message(event[:data][:content])
         when :tool_call
           display_tool_call(event[:data])
         when :observation
@@ -227,15 +233,15 @@ module Clacky
           # Auto-display TODO status if exists
           display_todo_status_if_exists
         when :answer
-          say "\n⏺ #{event[:data][:content]}", :white if event[:data][:content] && !event[:data][:content].empty?
+          formatter.assistant_message(event[:data][:content])
         when :tool_denied
-          say "\n⏺ Tool denied: #{event[:data][:name]}\n\n", :yellow
+          formatter.tool_denied(event[:data][:name])
         when :tool_planned
-          say "\n⏺ Planned: #{event[:data][:name]}", :blue
+          formatter.tool_planned(event[:data][:name])
         when :tool_error
-          say "\n⏺ Error: #{event[:data][:error].message}", :red
+          formatter.tool_error(event[:data][:error].message)
         when :on_iteration
-          say "\n--- Iteration #{event[:data][:iteration]} ---", :yellow if options[:verbose]
+          formatter.iteration(event[:data][:iteration]) if options[:verbose]
         end
       end
 
@@ -249,14 +255,14 @@ module Clacky
           begin
             args = JSON.parse(args_json, symbolize_names: true)
             formatted = tool.format_call(args)
-            say "\n⏺ #{formatted}", :cyan
+            ui_formatter.tool_call(formatted)
           rescue JSON::ParserError, StandardError => e
             say "⚠️  Warning: Failed to format tool call: #{e.message}", :yellow
-            say "\n⏺ #{tool_name}(...)", :cyan
+            ui_formatter.tool_call("#{tool_name}(...)")
           end
         else
           say "⚠️  Warning: Tool instance not found for '#{tool_name}'", :yellow
-          say "\n⏺ #{tool_name}(...)", :cyan
+          ui_formatter.tool_call("#{tool_name}(...)")
         end
 
         # Show verbose details if requested
@@ -274,15 +280,15 @@ module Clacky
         if tool
           begin
             summary = tool.format_result(result)
-            say "  ⎿ #{summary}", :white
+            ui_formatter.tool_result(summary)
           rescue StandardError => e
-            say "  ⎿ Done", :white
+            ui_formatter.tool_result("Done")
           end
         else
           # Fallback for unknown tools
           result_str = result.to_s
           summary = result_str.length > 100 ? "#{result_str[0..100]}..." : result_str
-          say "  ⎿ #{summary}", :white
+          ui_formatter.tool_result(summary)
         end
 
         # Show verbose details if requested
@@ -313,42 +319,7 @@ module Clacky
         todos = @current_agent.todos
         return if todos.empty?
 
-        # Count statuses
-        completed = todos.count { |t| t[:status] == "completed" }
-        total = todos.size
-
-        # Build progress bar
-        progress_bar = todos.map { |t| t[:status] == "completed" ? "✓" : "○" }.join
-
-        # Check if all completed
-        if completed == total
-          say "\n📋 Tasks [#{completed}/#{total}]: #{progress_bar} 🎉 All completed!", :green
-          return
-        end
-
-        # Find current and next tasks
-        current_task = todos.find { |t| t[:status] == "pending" }
-        next_task_index = todos.index(current_task)
-        next_task = next_task_index && todos[next_task_index + 1]
-
-        say "\n📋 Tasks [#{completed}/#{total}]: #{progress_bar}", :yellow
-        if current_task
-          say "   → Next: ##{current_task[:id]} - #{current_task[:task]}", :white
-        end
-        if next_task && next_task[:status] == "pending"
-          say "   ⇢ After that: ##{next_task[:id]} - #{next_task[:task]}", :white
-        end
-      end
-
-      def display_agent_result(result)
-        say "\n" + ("=" * 60), :cyan
-        say "Agent Session Complete", :green
-        say "=" * 60, :cyan
-        say "Status: #{result[:status]}", :green
-        say "Iterations: #{result[:iterations]}", :yellow
-        say "Duration: #{result[:duration_seconds].round(2)}s", :yellow
-        say "Total Cost: $#{result[:total_cost_usd]}", :yellow
-        say "=" * 60, :cyan
+        ui_formatter.todo_status(todos)
       end
 
       def validate_working_directory(path)
@@ -387,26 +358,37 @@ module Clacky
         # Store agent as instance variable for access in display methods
         @current_agent = agent
 
+        # Initialize UI components
+        banner = ui_banner
+        prompt = ui_prompt
+        statusbar = ui_statusbar
+
+        # Show startup banner for new session
+        if agent.total_tasks == 0
+          banner.display_startup
+        end
+
         # Show session info if continuing
         if agent.total_tasks > 0
-          say "Continuing session: #{agent.session_id[0..7]}", :cyan
-          say "Created: #{Time.parse(agent.created_at).strftime('%Y-%m-%d %H:%M')}", :cyan
-          say "Tasks completed: #{agent.total_tasks}", :cyan
-          say "Total cost: $#{agent.total_cost.round(4)}", :cyan
-          say ""
+          banner.display_session_continue(
+            session_id: agent.session_id[0..7],
+            created_at: Time.parse(agent.created_at).strftime('%Y-%m-%d %H:%M'),
+            tasks: agent.total_tasks,
+            cost: agent.total_cost.round(4)
+          )
 
           # Show recent conversation history
           display_recent_messages(agent.messages, limit: 5)
+        else
+          # Show welcome info for new session
+          banner.display_agent_welcome(
+            working_dir: working_dir,
+            mode: agent_config.permission_mode,
+            max_iterations: agent_config.max_iterations,
+            max_cost: agent_config.max_cost_usd
+          )
         end
 
-        say "🤖 Starting interactive agent mode...", :green
-        say "Working directory: #{working_dir}", :cyan
-        say "Mode: #{agent_config.permission_mode}", :yellow
-        say "Max iterations: #{agent_config.max_iterations} per task", :yellow
-        say "Max cost: $#{agent_config.max_cost_usd} per task", :yellow
-        say "\nType 'exit' or 'quit' to end the session.\n", :yellow
-
-        prompt = TTY::Prompt.new
         total_tasks = agent.total_tasks
         total_cost = agent.total_cost
 
@@ -418,15 +400,26 @@ module Clacky
           unless current_message && !current_message.strip.empty?
             say "\n" if total_tasks > 0
 
-            # Use Readline for better Unicode/CJK support
-            current_message = Readline.readline("You: ", true)
+            # Show status bar before input
+            statusbar.display(
+              working_dir: working_dir,
+              mode: agent_config.permission_mode.to_s,
+              model: agent_config.model,
+              tasks: total_tasks,
+              cost: total_cost
+            )
+
+            # Use enhanced prompt with "You:" prefix
+            current_message = prompt.read_input(prefix: "You:")
 
             break if current_message.nil? || %w[exit quit].include?(current_message&.downcase&.strip)
             next if current_message.strip.empty?
+            
+            # Display user's message after input
+            ui_formatter.user_message(current_message)
           end
 
           total_tasks += 1
-          say "\n"
 
           begin
             result = agent.run(current_message) do |event|
@@ -441,17 +434,18 @@ module Clacky
             end
 
             # Show brief task completion
-            say "\n" + ("-" * 60), :cyan
-            say "✓ Task completed", :green
-            say "  Iterations: #{result[:iterations]}", :white
-            say "  Cost: $#{result[:total_cost_usd].round(4)}", :white
-            say "  Session total: #{total_tasks} tasks, $#{total_cost.round(4)}", :yellow
-            say "-" * 60, :cyan
+            banner.display_task_complete(
+              iterations: result[:iterations],
+              cost: result[:total_cost_usd].round(4),
+              total_tasks: total_tasks,
+              total_cost: total_cost.round(4),
+              cache_stats: result[:cache_stats]
+            )
           rescue Clacky::AgentInterrupted
             # Save session on interruption
             if session_manager
               session_manager.save(agent.to_session_data(status: :interrupted))
-              say "\n\n⚠️  Task interrupted by user (Ctrl+C)", :yellow
+              ui_formatter.warning("Task interrupted by user (Ctrl+C)")
               say "You can start a new task or type 'exit' to quit.\n", :yellow
             end
           rescue StandardError => e
@@ -461,17 +455,15 @@ module Clacky
             end
 
             # Report the error
-            say "\n❌ Error: #{e.message}", :red
-            say e.backtrace.first(3).join("\n"), :white if options[:verbose]
-            
+            banner.display_error(e.message, details: options[:verbose] ? e.backtrace.first(3).join("\n") : nil)
+
             # Show session saved message
             if session_manager&.last_saved_path
-              say "\n📂 Session saved: #{session_manager.last_saved_path}", :yellow
+              ui_formatter.info("Session saved: #{session_manager.last_saved_path}")
             end
 
             # Guide user to recover
-            say "\n💡 To recover and retry, run:", :yellow
-            say "   clacky agent -c", :cyan
+            ui_formatter.info("To recover and retry, run: clacky agent -c")
             say "\nOr you can continue with a new task or type 'exit' to quit.", :yellow
           end
 
@@ -484,9 +476,10 @@ module Clacky
           session_manager.save(agent.to_session_data)
         end
 
-        say "\n👋 Agent session ended", :green
-        say "Total tasks completed: #{total_tasks}", :cyan
-        say "Total cost: $#{total_cost.round(4)}", :cyan
+        banner.display_goodbye(
+          total_tasks: total_tasks,
+          total_cost: total_cost.round(4)
+        )
       end
 
       def list_sessions
@@ -582,21 +575,23 @@ module Clacky
           return
         end
 
-        say "📜 Recent conversation history:\n", :yellow
-        say "-" * 60, :white
+        formatter = ui_formatter
+        formatter.separator("─")
+        say pastel.dim("Recent conversation history:"), :yellow
+        formatter.separator("─")
 
         recent.each do |msg|
           case msg[:role]
           when "user"
             content = truncate_message(msg[:content], 150)
-            say "\n👤 You: #{content}", :cyan
+            say "  #{pastel.blue('[>>]')} You: #{content}"
           when "assistant"
             content = truncate_message(msg[:content], 200)
-            say "🤖 Assistant: #{content}", :green
+            say "  #{pastel.green('[<<]')} Assistant: #{content}"
           end
         end
 
-        say "\n" + ("-" * 60), :white
+        formatter.separator("─")
         say ""
       end
 
@@ -612,6 +607,27 @@ module Clacky
           cleaned
         end
       end
+
+      # UI component accessors
+      def ui_banner
+        @ui_banner ||= UI::Banner.new
+      end
+
+      def ui_prompt
+        @ui_prompt ||= UI::Prompt.new
+      end
+
+      def ui_statusbar
+        @ui_statusbar ||= UI::StatusBar.new
+      end
+
+      def ui_formatter
+        @ui_formatter ||= UI::Formatter.new
+      end
+
+      def pastel
+        @pastel ||= Pastel.new
+      end
     end
 
     private

data/lib/clacky/client.rb

@@ -43,7 +43,9 @@ module Clacky
     end
 
     # Send messages with function calling (tools) support
-    def send_messages_with_tools(messages, model:, tools:, max_tokens:, verbose: false)
+    # Options:
+    #   - enable_caching: Enable prompt caching for system prompt and tools (default: false)
+    def send_messages_with_tools(messages, model:, tools:, max_tokens:, verbose: false, enable_caching: false)
       body = {
         model: model,
         max_tokens: max_tokens,
@@ -51,7 +53,18 @@ module Clacky
       }
 
       # Add tools if provided
-      body[:tools] = tools if tools&.any?
+      # For Claude API with caching: mark the last tool definition with cache_control
+      if tools&.any?
+        if enable_caching && supports_prompt_caching?(model)
+          # Deep clone tools to avoid modifying original
+          cached_tools = tools.map { |tool| deep_clone(tool) }
+          # Mark the last tool for caching (Claude caches from cache breakpoint to end)
+          cached_tools.last[:cache_control] = { type: "ephemeral" }
+          body[:tools] = cached_tools
+        else
+          body[:tools] = tools
+        end
+      end
 
       # Debug output
       if verbose || ENV["CLACKY_DEBUG"]
@@ -77,6 +90,31 @@ module Clacky
 
     private
 
+    # Check if the model supports prompt caching
+    # Currently only Claude 3.5 Sonnet and newer Claude models support this
+    def supports_prompt_caching?(model)
+      model_str = model.to_s.downcase
+      # Claude 3.5 Sonnet (20241022 and newer) supports prompt caching
+      # Also Claude 3.7 Sonnet and Opus models when they're released
+      model_str.include?("claude-3.5-sonnet") ||
+        model_str.include?("claude-3-7") ||
+        model_str.include?("claude-4")
+    end
+
+    # Deep clone a hash/array structure (for tool definitions)
+    def deep_clone(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) { |(k, v), h| h[k] = deep_clone(v) }
+      when Array
+        obj.map { |item| deep_clone(item) }
+      when String, Symbol, Integer, Float, TrueClass, FalseClass, NilClass
+        obj
+      else
+        obj.dup rescue obj
+      end
+    end
+
     def connection
       @connection ||= Faraday.new(url: @base_url) do |conn|
         conn.headers["Content-Type"] = "application/json"
@@ -117,15 +155,26 @@ module Clacky
           puts "  content length: #{message["content"]&.length || 0}"
         end
 
+        # Parse usage with cache information
+        usage_data = {
+          prompt_tokens: usage["prompt_tokens"],
+          completion_tokens: usage["completion_tokens"],
+          total_tokens: usage["total_tokens"]
+        }
+        
+        # Add cache metrics if present (Claude API with prompt caching)
+        if usage["cache_creation_input_tokens"]
+          usage_data[:cache_creation_input_tokens] = usage["cache_creation_input_tokens"]
+        end
+        if usage["cache_read_input_tokens"]
+          usage_data[:cache_read_input_tokens] = usage["cache_read_input_tokens"]
+        end
+        
         {
           content: message["content"],
           tool_calls: parse_tool_calls(message["tool_calls"]),
           finish_reason: data["choices"].first["finish_reason"],
-          usage: {
-            prompt_tokens: usage["prompt_tokens"],
-            completion_tokens: usage["completion_tokens"],
-            total_tokens: usage["total_tokens"]
-          }
+          usage: usage_data
         }
       when 401
         raise Error, "Invalid API key"