console_agent 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f82de0e3bdd6d1e3189c3b1bd0c88c386a6b31b4dff317656365352490f06c9
-  data.tar.gz: 1347a93e946c254809cdf6bfa90e3dea0378b7aef9a5e04950bdf0151569cd79
+  metadata.gz: dc46d0592feb84b4d85481d1535dccbe417a4445593828424c12a84d96fcbc9c
+  data.tar.gz: 10fe29dc81cc425a498c6e7d6c6b82aaa586ec674c081ba3f7b5b1143b68df18
 SHA512:
-  metadata.gz: cec5e56aaddea19c5d1b9046fcbd7fd4707d16efa3fab65f9977703e24d28d177c12331c9cba7590048b1ad2f412d67bcb9ffe78c5cef288d6da40916cb53a86
-  data.tar.gz: 9e67f0c30bbd38561c400523ca19240f931ff5c08b353fa545037472b6b2195f931b5987b21d3c643a35e2cb3377647447cc676aa7544ba5a2ccec2a505f7e16
+  metadata.gz: 86760d6c3b7c4920fc2c01741be308fc3d3f133e264c8dc37cab6b1ab90e9b920a410d57c86d8f96e743396d6919735d7fad62ee584667c8ea177c4825a12d05
+  data.tar.gz: 6446b9b2af4803ccd860fd109484ef37de87850517ad117eb52892974a65a017c1b03188dfc1eb7f24aad3859749ce4f6d282220c8d5d78238e67cfdb7438def

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.10.0]
+
+- Add `/expand` command to view previous results
+- Exclude previous output from context; add tool for LLM to retrieve it on demand
+- Show summarized info per LLM call in `/debug`
+
+## [0.9.0]
+
+- Add `/system` and `/context` commands to inspect what is being sent
+- Omit huge output from tool results
+- Don't cancel code execution on incorrect prompt answers
+- Preserve code blocks when compacting; require manual `/compact`
+- Fix authentication when neither method was applied
+- Remove prompt to upgrade model on excessive tool calls
+
 ## [0.8.0]
 
 - Add authentication function support so host apps can avoid using basic auth

data/README.md

@@ -79,7 +79,10 @@ end
 | `/usage` | Show token stats |
 | `/cost` | Show per-model cost breakdown |
 | `/think` | Upgrade to thinking model (Opus) for the rest of the session |
-| `/debug` | Toggle raw API output |
+| `/debug` | Toggle debug summaries (context stats, cost per call) |
+| `/expand <id>` | Show full omitted output |
+| `/context` | Show conversation history as sent to the LLM |
+| `/system` | Show the system prompt |
 | `/name <label>` | Name the session for easy resume |
 
 Prefix input with `>` to run Ruby directly (no LLM round-trip). The result is added to conversation context.
@@ -96,6 +99,8 @@ Say "think harder" in any query to auto-upgrade to the thinking model for that s
 - **App guide** — `ai_init` generates a guide injected into every system prompt
 - **Sessions** — name, list, and resume interactive conversations (`ai_setup` to enable)
 - **History compaction** — `/compact` summarizes long conversations to reduce cost and latency
+- **Output trimming** — older execution outputs are automatically replaced with references; the LLM can recall them on demand via `recall_output`, and you can `/expand <id>` to see them
+- **Debug mode** — `/debug` shows context breakdown, token counts, and per-call cost estimates before and after each LLM call
 
 ## Configuration
 

data/lib/console_agent/executor.rb

@@ -48,6 +48,10 @@ module ConsoleAgent
 
     def initialize(binding_context)
       @binding_context = binding_context
+      @omitted_outputs = {}
+      @omitted_counter = 0
+      @output_store = {}
+      @output_counter = 0
     end
 
     def extract_code(response)
@@ -107,6 +111,20 @@ module ConsoleAgent
       @last_output
     end
 
+    def expand_output(id)
+      @omitted_outputs[id]
+    end
+
+    def store_output(content)
+      @output_counter += 1
+      @output_store[@output_counter] = content
+      @output_counter
+    end
+
+    def recall_output(id)
+      @output_store[id]
+    end
+
     def last_answer
       @last_answer
     end
@@ -185,7 +203,10 @@ module ConsoleAgent
         parts = []
         parts << "#{omitted_lines} lines" if omitted_lines > 0
         parts << "#{omitted_chars} chars" if omitted_chars > 0
-        $stdout.puts colorize("  (omitting #{parts.join(', ')})", :yellow)
+
+        @omitted_counter += 1
+        @omitted_outputs[@omitted_counter] = full
+        $stdout.puts colorize("  (omitting #{parts.join(', ')})  /expand #{@omitted_counter} to see all", :yellow)
       end
     end
 

data/lib/console_agent/providers/base.rb

@@ -41,24 +41,27 @@ module ConsoleAgent
       def debug_request(url, body)
         return unless config.debug
 
-        $stderr.puts "\e[33m--- ConsoleAgent DEBUG: REQUEST ---\e[0m"
-        $stderr.puts "\e[33mURL: #{url}\e[0m"
-        parsed = body.is_a?(String) ? JSON.parse(body) : body
-        $stderr.puts "\e[33m#{JSON.pretty_generate(parsed)}\e[0m"
-        $stderr.puts "\e[33m--- END REQUEST ---\e[0m"
-      rescue => e
-        $stderr.puts "\e[33m[debug] #{body}\e[0m"
+        parsed = body.is_a?(String) ? (JSON.parse(body) rescue nil) : body
+        if parsed
+          # Support both symbol and string keys
+          model = parsed[:model] || parsed['model']
+          msgs = parsed[:messages] || parsed['messages']
+          sys = parsed[:system] || parsed['system']
+          tools = parsed[:tools] || parsed['tools']
+          $stderr.puts "\e[33m[debug] POST #{url} | model: #{model} | #{msgs&.length || 0} msgs | system: #{sys.to_s.length} chars | #{tools&.length || 0} tools\e[0m"
+        else
+          $stderr.puts "\e[33m[debug] POST #{url}\e[0m"
+        end
       end
 
       def debug_response(body)
         return unless config.debug
 
-        $stderr.puts "\e[36m--- ConsoleAgent DEBUG: RESPONSE ---\e[0m"
-        parsed = body.is_a?(String) ? JSON.parse(body) : body
-        $stderr.puts "\e[36m#{JSON.pretty_generate(parsed)}\e[0m"
-        $stderr.puts "\e[36m--- END RESPONSE ---\e[0m"
-      rescue => e
-        $stderr.puts "\e[36m[debug] #{body}\e[0m"
+        parsed = body.is_a?(String) ? (JSON.parse(body) rescue nil) : body
+        if parsed && parsed['usage']
+          u = parsed['usage']
+          $stderr.puts "\e[36m[debug] response: #{parsed['stop_reason']} | in: #{u['input_tokens']} out: #{u['output_tokens']}\e[0m"
+        end
       end
 
       def parse_response(response)

data/lib/console_agent/repl.rb

@@ -285,6 +285,17 @@ module ConsoleAgent
           next
         end
 
+        if input.start_with?('/expand')
+          expand_id = input.sub('/expand', '').strip.to_i
+          full_output = @executor.expand_output(expand_id)
+          if full_output
+            @interactive_old_stdout.puts full_output
+          else
+            @interactive_old_stdout.puts "\e[33mNo omitted output with id #{expand_id}\e[0m"
+          end
+          next
+        end
+
         if input == '/think'
           upgrade_to_thinking_model
           next
@@ -326,7 +337,8 @@ module ConsoleAgent
 
           context_msg = "User directly executed code: `#{raw_code}`"
           context_msg += "\n#{result_str}" unless output_parts.empty?
-          @history << { role: :user, content: context_msg }
+          output_id = output_parts.empty? ? nil : @executor.store_output(result_str)
+          @history << { role: :user, content: context_msg, output_id: output_id }
 
           @interactive_query ||= input
           @last_interactive_code = raw_code
@@ -459,7 +471,8 @@ module ConsoleAgent
         unless output_parts.empty?
           result_str = output_parts.join("\n\n")
           result_str = result_str[0..1000] + '...' if result_str.length > 1000
-          @history << { role: :user, content: "Code was executed. #{result_str}" }
+          output_id = @executor.store_output(result_str)
+          @history << { role: :user, content: "Code was executed. #{result_str}", output_id: output_id }
         end
 
         :success
@@ -547,6 +560,10 @@ module ConsoleAgent
       prompt.strip
     end
 
+    # Number of most recent execution outputs to keep in full in the conversation.
+    # Older outputs are replaced with a short reference the LLM can recall via tool.
+    RECENT_OUTPUTS_TO_KEEP = 2
+
     def send_query(query, conversation: nil)
       ConsoleAgent.configuration.validate!
 
@@ -556,6 +573,8 @@ module ConsoleAgent
                    [{ role: :user, content: query }]
                  end
 
+      messages = trim_old_outputs(messages) if conversation
+
       send_query_with_tools(messages)
     end
 
@@ -586,6 +605,10 @@ module ConsoleAgent
           $stdout.puts "\e[2m  #{llm_status(round, messages, total_input, last_thinking, last_tool_names)}\e[0m"
         end
 
+        if ConsoleAgent.configuration.debug
+          debug_pre_call(round, messages, active_system_prompt, tools, total_input, total_output)
+        end
+
         begin
           result = with_escape_monitoring do
             provider.chat_with_tools(messages, tools: tools, system_prompt: active_system_prompt)
@@ -596,6 +619,10 @@ module ConsoleAgent
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
 
+        if ConsoleAgent.configuration.debug
+          debug_post_call(round, result, @total_input_tokens + total_input, @total_output_tokens + total_output)
+        end
+
         break unless result.tool_use?
 
         # Buffer thinking text for display before next LLM call
@@ -624,10 +651,14 @@ module ConsoleAgent
           end
 
           if ConsoleAgent.configuration.debug
-            $stderr.puts "\e[35m[debug tool result] #{tool_result}\e[0m"
+            $stderr.puts "\e[35m[debug] tool result (#{tool_result.to_s.length} chars)\e[0m"
           end
 
           tool_msg = provider.format_tool_result(tc[:id], tool_result)
+          # Store large tool results so they can be trimmed from older conversation turns
+          if tool_result.to_s.length > 200
+            tool_msg[:output_id] = @executor.store_output(tool_result.to_s)
+          end
           messages << tool_msg
           new_messages << tool_msg
         end
@@ -712,6 +743,89 @@ module ConsoleAgent
       status
     end
 
+    def debug_pre_call(round, messages, system_prompt, tools, total_input, total_output)
+      d = "\e[35m"
+      r = "\e[0m"
+
+      # Count message types
+      user_msgs = 0
+      assistant_msgs = 0
+      tool_result_msgs = 0
+      tool_use_msgs = 0
+      output_msgs = 0
+      omitted_msgs = 0
+      total_content_chars = system_prompt.to_s.length
+
+      messages.each do |msg|
+        content_str = msg[:content].is_a?(Array) ? msg[:content].to_s : msg[:content].to_s
+        total_content_chars += content_str.length
+
+        role = msg[:role].to_s
+        if role == 'tool'
+          tool_result_msgs += 1
+        elsif msg[:content].is_a?(Array)
+          # Anthropic format — check for tool_result or tool_use blocks
+          msg[:content].each do |block|
+            next unless block.is_a?(Hash)
+            if block['type'] == 'tool_result'
+              tool_result_msgs += 1
+              omitted_msgs += 1 if block['content'].to_s.include?('Output omitted')
+            elsif block['type'] == 'tool_use'
+              tool_use_msgs += 1
+            end
+          end
+        elsif role == 'user'
+          user_msgs += 1
+          if content_str.include?('Code was executed') || content_str.include?('directly executed code')
+            output_msgs += 1
+            omitted_msgs += 1 if content_str.include?('Output omitted')
+          end
+        elsif role == 'assistant'
+          assistant_msgs += 1
+        end
+      end
+
+      tool_count = tools.respond_to?(:definitions) ? tools.definitions.length : 0
+
+      $stderr.puts "#{d}[debug] ── LLM call ##{round + 1} ──#{r}"
+      $stderr.puts "#{d}[debug]   system prompt: #{format_tokens(system_prompt.to_s.length)} chars#{r}"
+      $stderr.puts "#{d}[debug]   messages: #{messages.length} (#{user_msgs} user, #{assistant_msgs} assistant, #{tool_result_msgs} tool results, #{tool_use_msgs} tool calls)#{r}"
+      $stderr.puts "#{d}[debug]   execution outputs: #{output_msgs} (#{omitted_msgs} omitted)#{r}" if output_msgs > 0 || omitted_msgs > 0
+      $stderr.puts "#{d}[debug]   tools provided: #{tool_count}#{r}"
+      $stderr.puts "#{d}[debug]   est. content size: #{format_tokens(total_content_chars)} chars#{r}"
+      if total_input > 0 || total_output > 0
+        $stderr.puts "#{d}[debug]   tokens so far: in: #{format_tokens(total_input)} | out: #{format_tokens(total_output)}#{r}"
+      end
+    end
+
+    def debug_post_call(round, result, total_input, total_output)
+      d = "\e[35m"
+      r = "\e[0m"
+
+      input_t = result.input_tokens || 0
+      output_t = result.output_tokens || 0
+      model = ConsoleAgent.configuration.resolved_model
+      pricing = Configuration::PRICING[model]
+
+      parts = ["in: #{format_tokens(input_t)}", "out: #{format_tokens(output_t)}"]
+
+      if pricing
+        cost = (input_t * pricing[:input]) + (output_t * pricing[:output])
+        session_cost = (total_input * pricing[:input]) + (total_output * pricing[:output])
+        parts << "~$#{'%.4f' % cost}"
+        $stderr.puts "#{d}[debug]   ← response: #{parts.join(' | ')}  (session: ~$#{'%.4f' % session_cost})#{r}"
+      else
+        $stderr.puts "#{d}[debug]   ← response: #{parts.join(' | ')}#{r}"
+      end
+
+      if result.tool_use?
+        tool_names = result.tool_calls.map { |tc| tc[:name] }
+        $stderr.puts "#{d}[debug]   tool calls: #{tool_names.join(', ')}#{r}"
+      else
+        $stderr.puts "#{d}[debug]   stop reason: #{result.stop_reason}#{r}"
+      end
+    end
+
     def format_tokens(count)
       if count >= 1_000_000
         "#{(count / 1_000_000.0).round(1)}M"
@@ -975,6 +1089,54 @@ module ConsoleAgent
       config.resolved_model == config.resolved_thinking_model
     end
 
+    # Replace older execution outputs with short references.
+    # Keeps the last RECENT_OUTPUTS_TO_KEEP outputs in full.
+    def trim_old_outputs(messages)
+      # Find indices of messages with output_id (execution outputs and tool results)
+      output_indices = messages.each_with_index
+                               .select { |m, _| m[:output_id] }
+                               .map { |_, i| i }
+
+      if output_indices.length <= RECENT_OUTPUTS_TO_KEEP
+        return messages.map { |m| m.except(:output_id) }
+      end
+
+      # Indices to trim (all except the most recent N)
+      trim_indices = output_indices[0..-(RECENT_OUTPUTS_TO_KEEP + 1)]
+      messages.each_with_index.map do |msg, i|
+        if trim_indices.include?(i)
+          trim_message(msg)
+        else
+          msg.except(:output_id)
+        end
+      end
+    end
+
+    # Replace the content of a message with a short reference to the stored output.
+    # Handles both regular messages and tool result messages (Anthropic/OpenAI formats).
+    def trim_message(msg)
+      ref = "[Output omitted — use recall_output tool with id #{msg[:output_id]} to retrieve]"
+
+      if msg[:content].is_a?(Array)
+        # Anthropic tool_result format: [{ 'type' => 'tool_result', 'tool_use_id' => '...', 'content' => '...' }]
+        trimmed_content = msg[:content].map do |block|
+          if block.is_a?(Hash) && block['type'] == 'tool_result'
+            block.merge('content' => ref)
+          else
+            block
+          end
+        end
+        { role: msg[:role], content: trimmed_content }
+      elsif msg[:role].to_s == 'tool'
+        # OpenAI tool result format
+        msg.except(:output_id).merge(content: ref)
+      else
+        # Regular user message (code execution result)
+        first_line = msg[:content].to_s.lines.first&.strip || msg[:content]
+        { role: msg[:role], content: "#{first_line}\n#{ref}" }
+      end
+    end
+
     def warn_if_history_large
       chars = @history.sum { |m| m[:content].to_s.length }
 
@@ -1123,13 +1285,14 @@ module ConsoleAgent
         return
       end
 
-      @interactive_old_stdout.puts "\e[36m  Conversation (#{@history.length} messages):\e[0m"
-      @history.each_with_index do |msg, i|
+      trimmed = trim_old_outputs(@history)
+      @interactive_old_stdout.puts "\e[36m  Conversation (#{trimmed.length} messages, as sent to LLM):\e[0m"
+      trimmed.each_with_index do |msg, i|
         role = msg[:role].to_s
         content = msg[:content].to_s
         label = role == 'user' ? "\e[33m[user]\e[0m" : "\e[36m[assistant]\e[0m"
         @interactive_old_stdout.puts "#{label} #{content}"
-        @interactive_old_stdout.puts if i < @history.length - 1
+        @interactive_old_stdout.puts if i < trimmed.length - 1
       end
     end
 
@@ -1144,7 +1307,8 @@ module ConsoleAgent
       @interactive_old_stdout.puts "\e[2m    /name <lbl>  Name this session for easy resume\e[0m"
       @interactive_old_stdout.puts "\e[2m    /context     Show conversation history sent to the LLM\e[0m"
       @interactive_old_stdout.puts "\e[2m    /system      Show the system prompt\e[0m"
-      @interactive_old_stdout.puts "\e[2m    /debug       Toggle debug mode\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /expand <id> Show full omitted output\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /debug       Toggle debug summaries (context stats, cost per call)\e[0m"
       @interactive_old_stdout.puts "\e[2m    > code       Execute Ruby directly (skip LLM)\e[0m"
       @interactive_old_stdout.puts "\e[2m    exit/quit    Leave interactive mode\e[0m"
     end

data/lib/console_agent/tools/registry.rb

@@ -170,6 +170,24 @@ module ConsoleAgent
           handler: ->(args) { code.search_code(args['query'], args['directory']) }
         )
 
+        if @executor
+          register(
+            name: 'recall_output',
+            description: 'Retrieve a previous code execution output that was omitted from the conversation to save context. Use the output id shown in the "[Output omitted]" placeholder.',
+            parameters: {
+              'type' => 'object',
+              'properties' => {
+                'id' => { 'type' => 'integer', 'description' => 'The output id to retrieve' }
+              },
+              'required' => ['id']
+            },
+            handler: ->(args) {
+              result = @executor.recall_output(args['id'].to_i)
+              result || "No output found with id #{args['id']}"
+            }
+          )
+        end
+
         unless @mode == :init
           register(
             name: 'ask_user',

data/lib/console_agent/version.rb

@@ -1,3 +1,3 @@
 module ConsoleAgent
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.10.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: console_agent
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Cortfr