Merge pull request #3 from scientist-labs/wrap-errors

Wrap generation errors with helpful messages

Author: cpetersen

lib/ruby_llm/red_candle/chat.rb

@@ -67,7 +67,7 @@ def perform_completion!(payload)
                      prompt = build_prompt(model, messages)
                      validate_context_length!(prompt, payload[:model])
                      config = build_generation_config(payload)
-                     model.generate(prompt, config: config)
+                     generate_with_error_handling(model, prompt, config, payload[:model])
                    end
 
         format_response(response, payload[:schema])
@@ -84,8 +84,8 @@ def perform_streaming_completion!(payload, &block)
         # Collect all streamed content
         full_content = ""
 
-        # Stream tokens
-        model.generate_stream(prompt, config: config) do |token|
+        # Stream tokens with error handling
+        stream_with_error_handling(model, prompt, config, payload[:model]) do |token|
           full_content += token
           chunk = format_stream_chunk(token)
           block.call(chunk)
@@ -189,6 +189,44 @@ def model_error_message(exception, model_id)
         ERROR_MESSAGE
       end
 
+      def generate_with_error_handling(model, prompt, config, model_id)
+        model.generate(prompt, config: config)
+      rescue StandardError => e
+        raise RubyLLM::Error.new(nil, generation_error_message(e, model_id))
+      end
+
+      def stream_with_error_handling(model, prompt, config, model_id, &block)
+        model.generate_stream(prompt, config: config, &block)
+      rescue StandardError => e
+        raise RubyLLM::Error.new(nil, generation_error_message(e, model_id))
+      end
+
+      def generation_error_message(exception, model_id)
+        message = exception.message.to_s
+
+        if message.include?("out of memory") || message.include?("OOM")
+          <<~ERROR_MESSAGE.strip
+            Out of memory while generating with #{model_id}.
+            Try using a smaller model or reducing the context length.
+            Original error: #{message}
+          ERROR_MESSAGE
+        elsif message.include?("context") || message.include?("sequence")
+          <<~ERROR_MESSAGE.strip
+            Context length exceeded for #{model_id}.
+            The input is too long for this model's context window.
+            Original error: #{message}
+          ERROR_MESSAGE
+        elsif message.include?("tensor") || message.include?("shape")
+          <<~ERROR_MESSAGE.strip
+            Model execution error for #{model_id}.
+            This may indicate an incompatible model format or corrupted weights.
+            Original error: #{message}
+          ERROR_MESSAGE
+        else
+          "Generation failed for #{model_id}: #{message}"
+        end
+      end
+
       def format_messages(messages)
         messages.map do |msg|
           # Handle both hash and Message objects

spec/ruby_llm/red_candle/chat_spec.rb

@@ -87,6 +87,66 @@
           role: "assistant"
         )
       end
+
+      it "wraps generation errors with helpful messages" do
+        allow(mock_model).to receive(:generate).and_raise(StandardError, "raw error from candle")
+
+        payload = {
+          messages: messages,
+          model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+          temperature: 0.7
+        }
+
+        expect { provider.perform_completion!(payload) }.to raise_error(
+          RubyLLM::Error,
+          /Generation failed for TheBloke\/TinyLlama.*raw error from candle/
+        )
+      end
+
+      it "provides helpful message for out of memory errors" do
+        allow(mock_model).to receive(:generate).and_raise(StandardError, "out of memory")
+
+        payload = {
+          messages: messages,
+          model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+          temperature: 0.7
+        }
+
+        expect { provider.perform_completion!(payload) }.to raise_error(
+          RubyLLM::Error,
+          /Out of memory.*Try using a smaller model/m
+        )
+      end
+
+      it "provides helpful message for context length errors" do
+        allow(mock_model).to receive(:generate).and_raise(StandardError, "context length exceeded")
+
+        payload = {
+          messages: messages,
+          model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+          temperature: 0.7
+        }
+
+        expect { provider.perform_completion!(payload) }.to raise_error(
+          RubyLLM::Error,
+          /Context length exceeded.*input is too long/m
+        )
+      end
+
+      it "provides helpful message for tensor/shape errors" do
+        allow(mock_model).to receive(:generate).and_raise(StandardError, "tensor shape mismatch")
+
+        payload = {
+          messages: messages,
+          model: "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
+          temperature: 0.7
+        }
+
+        expect { provider.perform_completion!(payload) }.to raise_error(
+          RubyLLM::Error,
+          /Model execution error.*incompatible model format/m
+        )
+      end
     end
 
     context "with structured generation" do
@@ -113,7 +173,7 @@
         schema = { type: "object", properties: { name: { type: "string" } } }
 
         allow(mock_model).to receive(:generate_structured).and_raise(StandardError, "Structured gen failed")
-        allow(RubyLLM.logger).to receive(:error)
+        allow(RubyLLM.logger).to receive(:debug)
 
         payload = {
           messages: messages,
@@ -126,7 +186,7 @@
           RubyLLM::Error,
           /Structured generation failed/
         )
-        expect(RubyLLM.logger).to have_received(:error).at_least(:once)
+        expect(RubyLLM.logger).to have_received(:debug).at_least(:once)
       end
 
       it "normalizes schema keys to symbols" do