roast-ai 1.0.2 → 1.2.0

data/lib/roast/cogs/chat.rb

@@ -20,6 +20,14 @@ module Roast
     #
     # For tasks requiring local filesystem access or locally-configured tools, use the `agent` cog instead.
     class Chat < Cog
+      # Raised when the LLM response hits the max token limit, indicating the output was
+      # truncated and should not be considered usable.
+      class MaxTokensExceededError < Cog::CogError; end
+
+      # Anthropic always sends a max_tokens value in the request payload with this fallback
+      # when the model metadata doesn't specify one (see ruby_llm's Anthropic::Chat#build_base_payload).
+      ANTHROPIC_DEFAULT_MAX_TOKENS = 4096
+
       # The configuration object for this chat cog instance
       #
       #: Roast::Cogs::Chat::Config
@@ -42,36 +50,100 @@ module Roast
         chat.messages[num_existing_messages..].each do |message|
           case message.role
           when :user
-            puts "[USER PROMPT] #{message.content}" if config.show_prompt?
+            Event << { block: { header: "USER PROMPT", content: message.content } } if config.show_prompt?
           when :assistant
-            puts "[LLM RESPONSE] #{message.content}" if config.show_response?
+            Event << { block: { header: "LLM RESPONSE", content: message.content } } if config.show_response?
           else
             # No other message types are expected, but let's show them if they do appear
             # but only the user has requested some form of output
-            puts "[UNKNOWN] #{message.content}" if config.show_prompt? || config.show_response?
+            Event << { block: { header: "UNKNOWN", content: message.content } } if config.show_prompt? || config.show_response?
           end
         end
         if config.show_stats?
           temperature = chat.instance_variable_get(:@temperature)
-          puts "[LLM STATS]"
-          puts "\tModel: #{response.model_id}"
-          puts "\tTemperature: #{format("%0.2f", temperature)}" if temperature
-          puts "\tInput Tokens: #{response.input_tokens}"
-          puts "\tOutput Tokens: #{response.output_tokens}"
+          lines = ["Model: #{response.model_id}"]
+          lines << "Temperature: #{format("%0.2f", temperature)}" if temperature
+          lines << "Input Tokens: #{response.input_tokens}"
+          lines << "Output Tokens: #{response.output_tokens}"
+          Event << { block: { header: "LLM STATS", content: lines.join("\n") } }
         end
 
+        verify_response_not_truncated!(response)
+
         Output.new(Session.from_chat(chat), response.content)
       end
 
       private
 
+      # Verify that the LLM response was not truncated by hitting the max token limit.
+      #
+      # ruby_llm does not expose a stop_reason/finish_reason from the provider response, so we
+      # detect truncation heuristically: if the output token count equals (or exceeds) the
+      # effective max token limit, the content was almost certainly cut off mid-generation.
+      #
+      # The effective limit is derived from the ruby_llm model registry, which is populated
+      # from models.dev and provider APIs. This lookup is decoupled from the chat instance's
+      # `assume_model_exists` setting — even when the chat call itself skips registry
+      # verification (the default), we still consult the registry for token-limit metadata.
+      #
+      # For Anthropic, the provider always sends max_tokens with a fallback of 4096 in the
+      # request payload, so if the model is not in the registry we replicate that fallback.
+      # For other providers, if the model is not in the registry, the check is skipped because
+      # we have no ceiling to compare against.
+      #
+      # Note: the `>=` boundary can produce false positives when output hits the limit exactly
+      # on a natural boundary. This is an unavoidable trade-off of the heuristic approach until
+      # ruby_llm exposes finish_reason.
+      #
+      #: (RubyLLM::Message) -> void
+      def verify_response_not_truncated!(response)
+        max_tokens = effective_max_tokens
+        return unless max_tokens
+        return unless response.output_tokens
+
+        if response.output_tokens >= max_tokens
+          raise MaxTokensExceededError,
+            "LLM response from #{response.model_id} was truncated at the max token limit " \
+              "(output: #{response.output_tokens} tokens, limit: #{max_tokens} tokens). " \
+              "The response content is likely incomplete and should not be used."
+        end
+      end
+
+      # Determine the effective max token limit for the chat request.
+      #
+      # Queries the ruby_llm model registry directly, independent of the chat instance's
+      # `assume_model_exists` setting. This ensures the token limit is available even when
+      # the chat call itself uses the default permissive mode.
+      #
+      # Returns nil if the model is not in the registry and the provider doesn't have a
+      # known default.
+      #
+      #: () -> Integer?
+      def effective_max_tokens
+        RubyLLM.models.find(config.valid_model, config.valid_provider!)&.max_tokens
+      rescue RubyLLM::ModelNotFoundError
+        # Anthropic always sends max_tokens with a 4096 fallback in the request payload
+        ANTHROPIC_DEFAULT_MAX_TOKENS if config.valid_provider! == :anthropic
+      end
+
       # Get a RubyLLM context configured for this chat cog
       #
       #: () -> RubyLLM::Context
       def ruby_llm_context
         @ruby_llm_context ||= RubyLLM.context do |context|
-          context.openai_api_key = config.valid_api_key!
-          context.openai_api_base = config.valid_base_url
+          case config.valid_provider!
+          when :openai
+            context.openai_api_key = config.valid_api_key!
+            context.openai_api_base = config.valid_base_url
+          when :anthropic
+            context.anthropic_api_key = config.valid_api_key!
+            context.anthropic_api_base = config.valid_base_url
+          when :perplexity
+            context.perplexity_api_key = config.valid_api_key!
+          when :gemini
+            context.gemini_api_key = config.valid_api_key!
+            context.gemini_api_base = config.valid_base_url
+          end
         end
       end
     end

data/lib/roast/event.rb

@@ -24,6 +24,7 @@ module Roast
       :end,
       :stdout,
       :stderr,
+      :block,
     ].freeze #: Array[Symbol]
 
     #: Array[TaskContext::PathElement]

data/lib/roast/event_monitor.rb

@@ -6,6 +6,8 @@ module Roast
     extend self
     include Kernel
 
+    BLOCK_SEPARATOR = ("─" * 40).freeze #: String
+
     class EventMonitorError < StandardError; end
 
     class EventMonitorAlreadyStartedError < EventMonitorError; end
@@ -116,17 +118,47 @@ module Roast
 
     #: (Event) -> void
     def handle_log_event(event)
-      Roast::Log.logger.add(event.log_severity, "#{format_path(event)} #{event.log_message}")
+      path = format_path(event)
+      event.log_message.lines.each_with_index do |line, idx|
+        path_prefix = idx.zero? ? path : "·" * path.length
+        Roast::Log.logger.add(event.log_severity, "#{path_prefix} #{line.rstrip}")
+      end
     end
 
     #: (Event) -> void
     def handle_stderr_event(event)
-      Roast::Log.logger.warn { "#{format_path(event)} ❯❯ #{event[:stderr]}" }
+      path = format_path(event)
+      event[:stderr].lines.each_with_index do |line, idx|
+        path_prefix = idx.zero? ? "#{path} ❯❯" : "#{"·" * path.length} ❙❙"
+        Roast::Log.logger.warn do
+          Roast::Log::Message.new(
+            type: :stderr,
+            text: "#{path_prefix} #{line.rstrip}",
+          )
+        end
+      end
     end
 
     #: (Event) -> void
     def handle_stdout_event(event)
-      Roast::Log.logger.info { "#{format_path(event)} ❯ #{event[:stdout]}" }
+      path = format_path(event)
+      event[:stdout].lines.each_with_index do |line, idx|
+        path_prefix = idx.zero? ? "#{path} ❯" : "#{"·" * path.length} ❙"
+        Roast::Log.logger.info do
+          Roast::Log::Message.new(
+            type: :stdout,
+            text: "#{path_prefix} #{line.rstrip}",
+          )
+        end
+      end
+    end
+
+    #: (Event) -> void
+    def handle_block_event(event)
+      block = event[:block]
+      header = "[#{block[:header]}]"
+      content = block[:content]
+      Roast::Log.logger.info { "#{format_path(event)} #{header}↓\n#{BLOCK_SEPARATOR}\n#{content}\n#{BLOCK_SEPARATOR}" }
     end
 
     #: (Event) -> void

data/lib/roast/log.rb

@@ -21,6 +21,27 @@ module Roast
     extend self
     include Kernel
 
+    # A log message paired with its originating type, so downstream handlers
+    # (e.g. the formatter) can render or route it by type.
+    class Message
+      #: Symbol
+      attr_reader :type
+
+      #: String
+      attr_reader :text
+
+      #: (type: Symbol, text: String) -> void
+      def initialize(type:, text:)
+        @type = type
+        @text = text
+      end
+
+      #: () -> String
+      def to_s
+        text
+      end
+    end
+
     LOG_LEVELS = {
       DEBUG: ::Logger::DEBUG,
       INFO: ::Logger::INFO,

data/lib/roast/log_formatter.rb

@@ -15,22 +15,22 @@ module Roast
     end
 
     def call(severity, time, _progname, msg)
+      type = msg.is_a?(Roast::Log::Message) ? msg.type : nil
       line = if @tty
         format(TTY_FORMAT, severity, msg2str(msg))
       else
         format(NON_TTY_FORMAT, severity, time.strftime(DATETIME_FORMAT), severity, msg2str(msg))
       end
-      colourize(severity, line)
+      colourize(severity, type, line)
     end
 
     private
 
-    #: (String, String) -> String
-    def colourize(severity, line)
-      if line.include?("❯❯") # standard error lines
-        @rainbow.wrap(line).yellow
-      elsif line.include?("❯") # standard output lines
-        @rainbow.wrap(line)
+    #: (String, Symbol?, String) -> String
+    def colourize(severity, type, line)
+      case type
+      when :stderr then @rainbow.wrap(line).yellow
+      when :stdout then @rainbow.wrap(line)
       else
         case severity
         when "ERROR", "FATAL" then @rainbow.wrap(line).red
@@ -47,6 +47,8 @@ module Roast
       msg = case msg
       when ::String
         msg.strip
+      when Roast::Log::Message
+        msg.text.strip
       else
         msg
       end

data/lib/roast/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Roast
-  VERSION = "1.0.2"
+  VERSION = "1.2.0"
 end

data/lib/roast.rb

@@ -34,9 +34,7 @@ require "async"
 require "async/semaphore"
 require "rainbow"
 require "ruby_llm"
-
-# Require project components that will not get automatically loaded
-require "roast/nil_assertions"
+require "type_toolkit"
 
 # Autoloading setup
 require "zeitwerk"

data/roast-ai.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency("activesupport", "~> 8.0")
   spec.add_dependency("async", ">= 2.34")
   spec.add_dependency("rainbow", ">= 3.0.0")
-  spec.add_dependency("ruby_llm", ">= 1.8")
+  spec.add_dependency("ruby_llm", ">= 1.13")
+  spec.add_dependency("type_toolkit", ">= 0.0.5")
   spec.add_dependency("zeitwerk", ">= 2.6")
 end