ruby-pi 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbecc54fc18679e9f16a0a09c27944df82b0a98fff7ead1dee99ba1a659aad02
-  data.tar.gz: 298e084a7df3b6689e628477ddbae866057a81ac472838623ce6eefccd01a431
+  metadata.gz: ae334e07e1a5788bfe62b1a1d721d565885ba0142dca6d9a238656b3835454a0
+  data.tar.gz: 3f68b1f787a4fa17fd6ea68ef1b4974c5bb625b76c3898786a9b23c0999c490b
 SHA512:
-  metadata.gz: cbb1ae3d3469f987b4ab7652cce23626e6e1a233c08636ab24dcda3c6151d0bc728d88658e575919840e393c84ce4efabbd5fa78f302c036993a0d1b3e79b354
-  data.tar.gz: 1132a860f026efc123813042eea18617242d036ec03ca425277cd2f9eba88a49f1cc2f461c6feee58fa021eeed8fbe42affee5c6f865ff6fad563809ede29479
+  metadata.gz: cc0289504d07435aa8e681a102bcdc4e27d8f4f8033ab73ea73c227e345ab64be93cc0fd8d3dd27d50c640d4758508e14a91b290fed02fd089477f73e5ea3d35
+  data.tar.gz: 031ad8a0ca080a0024f596ec05e57857bd7cab68dc9236ae5ada606f09bbeedea5e59142e01e6bdea2de032008a1624bd9ad0db78fd4ed6fc1ddcddaab53331b

data/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.10] - 2026-08-28
+
+### Security
+
+- **Malformed or truncated HTTP-200 streams were accepted (High)**: Added a shared bounded SSE decoder with UTF-8 validation, standards-compliant event framing, final-buffer processing, and typed retryable protocol errors. OpenAI now requires `data: [DONE]`, Anthropic requires `message_stop`, and Gemini requires a finish reason or explicit prompt block before emitting `:done`
+- **Model-controlled tool fan-out was unbounded (High)**: Parallel execution now uses a bounded pool with a default concurrency of four, rejects more than 32 calls per execution, and enforces a process-wide cap of 16 active or timed-out-but-still-running tools. Streaming output, tool arguments, tool-call count, SSE events, and retained error bodies also have hard memory limits
+- **Malformed model arguments could enter logs (Medium)**: Provider errors no longer embed raw tool arguments, and fallback diagnostics remove control characters and cap message length
+
+### Fixed (adversarial review round 8)
+
+- **Tool timeout results falsely implied failure was final (High)**: Timed-out work is now reported as `status: :timeout_unknown` with `completion_unknown?`. Sequential execution does not start later calls after an uncertain timeout; those calls return `status: :skipped`. Arbitrary in-process Ruby blocks are still cooperative and cannot be force-terminated safely
+- **Immutable agent results could crash on valid tool values (High)**: Result snapshots are cycle-aware and never call `dup` on arbitrary application objects. Non-JSON objects become bounded frozen diagnostic strings instead of raising from `initialize_copy` or recursing indefinitely
+- **Retry/fallback reset metadata ignored tool fragments (Medium)**: Reset events now report `partial_tool_calls` and set `partial_output` whenever either text or structured tool-call output was emitted
+- **Compaction ignored structured tool metadata (Medium)**: Token estimates and summary prompts now account for assistant tool calls, IDs, names, and arguments
+- **Invalid safety limits failed deep in execution (Medium)**: Agent iteration limits, tool timeouts, call limits, and concurrency limits now reject non-finite, zero, negative, or wrong-type values at construction
+- **Release gates covered tests only (Low)**: CI now runs dependency auditing, Lint/Security checks, gem build/install, and an installed-artifact load/version smoke test alongside Ruby 3.2-3.4 tests
+
+### Known limitation
+
+- Ruby cannot safely force-terminate an arbitrary in-process block. A timed-out tool may still finish and commit side effects, so callers must treat `completion_unknown?` as an indeterminate outcome and use idempotency keys. Enforceable cancellation requires isolated worker processes or an external job backend in a future execution API
+
 ## [0.1.9] - 2026-08-28
 
 ### Security

data/README.md

@@ -133,7 +133,8 @@ model.complete(messages: messages, stream: true) do |event|
   when :retry_start
     # A transient failure occurred after streaming may have begun. Discard
     # the previous attempt before the provider retries from the beginning.
-    # Payload includes: { provider:, attempt:, partial_output:, partial_chars: }
+    # Payload includes partial_chars and partial_tool_calls. Always discard
+    # all text and structured tool state from the failed attempt.
     clear_partial_output
   when :fallback_start
     # Only emitted by RubyPi::LLM::Fallback when the primary provider
@@ -240,7 +241,13 @@ registry.all                         # => [Definition, ...]
 Run tool calls in parallel or sequentially with automatic error handling and timeouts:
 
 ```ruby
-executor = RubyPi::Tools::Executor.new(registry, mode: :parallel, timeout: 30)
+executor = RubyPi::Tools::Executor.new(
+  registry,
+  mode: :parallel,
+  timeout: 30,
+  max_calls: 32,
+  max_concurrency: 4
+)
 
 results = executor.execute([
   { name: "create_post", arguments: { content: "Hello" } },
@@ -252,6 +259,7 @@ results.each do |r|
     puts "#{r.name}: #{r.value}"
   else
     puts "#{r.name} failed: #{r.error} (#{r.duration_ms}ms)"
+    reconcile_with_an_idempotency_key if r.completion_unknown?
   end
 end
 ```
@@ -263,6 +271,15 @@ end
 | `value` | Return value (on success) |
 | `error` | Error message (on failure) |
 | `duration_ms` | Execution time in milliseconds |
+| `status` | `:success`, `:error`, `:timeout_unknown`, or `:skipped` |
+| `completion_unknown?` | The deadline elapsed, but the in-process tool may still finish or commit side effects |
+| `skipped?` | Sequential execution did not start this call after an uncertain timeout |
+
+Parallel execution is bounded. A model response containing more than `max_calls`
+tool calls raises `RubyPi::ToolCallLimitError`, and the process refuses new work
+after 16 tools remain active. Ruby cannot safely kill an arbitrary
+in-process block, so use idempotency keys for side-effecting tools and treat
+`completion_unknown?` as indeterminate rather than as a confirmed rollback.
 
 ---
 

data/lib/ruby_pi/agent/core.rb

@@ -101,6 +101,12 @@ module RubyPi
         execution_mode: :parallel,
         tool_timeout: 30
       )
+        valid_timeout = tool_timeout.is_a?(Numeric) && !tool_timeout.is_a?(Complex) &&
+                        tool_timeout.finite? && tool_timeout.positive?
+        unless valid_timeout
+          raise ArgumentError, "tool_timeout must be a finite positive number, got #{tool_timeout.inspect}"
+        end
+
         @state = State.new(
           system_prompt: system_prompt,
           model: model,

data/lib/ruby_pi/agent/result.rb

@@ -143,25 +143,46 @@ module RubyPi
       # arrays still allowed callers (or later State mutations) to rewrite
       # nested messages, tool arguments, usage, and content in place.
       def deep_frozen_copy(value)
+        snapshot(value, {}.compare_by_identity).freeze
+      end
+
+      # Copies only JSON-like containers and immutable scalars. Arbitrary tool
+      # return objects are converted to a bounded diagnostic string instead of
+      # calling #dup, which may allocate resources, raise from initialize_copy,
+      # or recurse forever through cyclic structures.
+      def snapshot(value, memo)
+        if value.is_a?(Hash) || value.is_a?(Array)
+          return "[Circular]".freeze if memo.key?(value)
+
+          memo[value] = true
+        end
+
         copy = case value
                when Hash
                  value.each_with_object({}) do |(key, item), result|
-                   result[deep_frozen_copy(key)] = deep_frozen_copy(item)
+                   result[snapshot(key, memo).freeze] = snapshot(item, memo).freeze
                  end
                when Array
-                 value.map { |item| deep_frozen_copy(item) }
+                 value.map { |item| snapshot(item, memo).freeze }
                when String
                  value.dup
+               when NilClass, TrueClass, FalseClass, Symbol, Numeric
+                 value
                else
-                 begin
-                   value.dup
-                 rescue TypeError
-                   # Immutable scalar values (nil, symbols, numerics, booleans)
-                   # cannot be duplicated and are already safe to share.
-                   value
-                 end
+                 safe_object_snapshot(value)
                end
-        copy.freeze
+
+        memo.delete(value) if value.is_a?(Hash) || value.is_a?(Array)
+        copy
+      end
+
+      def safe_object_snapshot(value)
+        rendered = value.to_s
+        rendered = rendered.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�")
+        rendered = rendered.byteslice(0, 4096).scrub if rendered.bytesize > 4096
+        "#<#{value.class}: #{rendered}>"
+      rescue StandardError
+        "#<#{value.class}: uninspectable>"
       end
     end
   end

data/lib/ruby_pi/agent/state.rb

@@ -77,6 +77,10 @@ module RubyPi
         after_tool_call: nil,
         user_data: {}
       )
+        unless max_iterations.is_a?(Integer) && max_iterations.positive?
+          raise ArgumentError, "max_iterations must be a positive integer, got #{max_iterations.inspect}"
+        end
+
         @system_prompt = system_prompt
         @model = model
         @tools = tools

data/lib/ruby_pi/context/compaction.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 # lib/ruby_pi/context/compaction.rb
 #
 # RubyPi::Context::Compaction — Token estimation and context window management.
@@ -28,6 +30,7 @@ module RubyPi
       # Average characters per token — a rough heuristic that avoids the need
       # for provider-specific tokenizers. Errs on the conservative side.
       CHARS_PER_TOKEN = 4
+      SUMMARY_METADATA_LIMIT = 16_384
 
       # @return [Integer] the token threshold above which compaction triggers
       attr_reader :max_tokens
@@ -160,6 +163,8 @@ module RubyPi
 
         messages.each do |msg|
           total_chars += message_value(msg, :content).to_s.length
+          metadata = msg.reject { |key, _| key == :role || key == "role" || key == :content || key == "content" }
+          total_chars += serialized_message(metadata).length unless metadata.empty?
           # Account for role and structural overhead (~10 tokens per message)
           total_chars += 40
         end
@@ -202,7 +207,9 @@ module RubyPi
         transcript = messages.map do |msg|
           role = message_value(msg, :role).to_s.capitalize
           content = message_value(msg, :content).to_s
-          "#{role}: #{content}"
+          metadata = msg.reject { |key, _| key == :role || key == "role" || key == :content || key == "content" }
+          metadata_text = metadata.empty? ? nil : serialized_message(metadata).slice(0, SUMMARY_METADATA_LIMIT)
+          ["#{role}: #{content}", ("Structured metadata: #{metadata_text}" if metadata_text)].compact.join("\n")
         end.join("\n\n")
 
         "Summarize the following conversation, preserving all key facts, " \
@@ -214,6 +221,12 @@ module RubyPi
       def message_value(message, key)
         message[key] || message[key.to_s]
       end
+
+      def serialized_message(message)
+        JSON.generate(message)
+      rescue JSON::GeneratorError, TypeError
+        message.to_s
+      end
     end
   end
 end

data/lib/ruby_pi/errors.rb

@@ -39,6 +39,14 @@ module RubyPi
     end
   end
 
+  # Raised when an HTTP streaming response violates the provider's protocol.
+  # This includes malformed SSE data, invalid UTF-8, oversized events, and a
+  # connection that closes before the provider's terminal event arrives.
+  #
+  # It inherits from ApiError with a nil status code so BaseProvider treats a
+  # broken HTTP-200 stream like a transient transport failure and can retry it.
+  class StreamingProtocolError < ApiError; end
+
   # Raised when authentication fails (HTTP 401 or 403). Typically indicates
   # an invalid, expired, or missing API key.
   class AuthenticationError < ApiError
@@ -112,4 +120,12 @@ module RubyPi
       super(message || "Model returned tool calls but no tools are registered")
     end
   end
+
+  # Raised when a model asks the executor to exceed its configured per-turn
+  # tool-call safety limit.
+  class ToolCallLimitError < Error; end
+
+  # Raised when too many previously timed-out in-process tools are still
+  # running and accepting more work would risk thread exhaustion.
+  class ToolExecutionCapacityError < Error; end
 end

data/lib/ruby_pi/extensions/base.rb

@@ -72,14 +72,6 @@ module RubyPi
           end
         end
 
-        # Returns the extension name. Override in subclasses to provide
-        # a human-readable identifier.
-        #
-        # @return [String] the extension name
-        def name
-          super
-        end
-
         private
 
         # Returns the hooks hash defined directly on this class (not

data/lib/ruby_pi/llm/anthropic.rb

@@ -366,26 +366,28 @@ module RubyPi
         usage_data = {}
         finish_reason = nil
 
-        # Buffer for incomplete SSE lines across on_data chunks. Faraday's
-        # on_data callback delivers raw bytes as they arrive from the network,
-        # which may split SSE events mid-line. We accumulate a line buffer and
-        # process complete lines incrementally so that deltas reach the caller
-        # as soon as each SSE event is fully received — not after the entire
-        # response has been buffered.
-        #
-        # The buffer is BINARY because chunks arrive as ASCII-8BIT and may end
-        # mid-way through a multi-byte UTF-8 character; appending such a chunk
-        # to a UTF-8 buffer that already holds non-ASCII text raises
-        # Encoding::CompatibilityError. Each complete line is re-encoded to
-        # UTF-8 (and scrubbed) before parsing, so deltas reach the caller as
-        # valid UTF-8 strings.
-        sse_buffer = (+"").force_encoding(Encoding::BINARY)
+        sse_parser = SSEParser.new(provider: provider_name)
+        stream_completed = false
         response_status = nil
 
         # Accumulate error response body separately so ApiError gets the
         # full body even though on_data consumed the chunks.
         error_body = (+"").force_encoding(Encoding::BINARY)
 
+        process_payload = proc do |data_str|
+          next if data_str == "[DONE]"
+
+          data = sse_parser.parse_json(data_str)
+          stream_completed = true if data["type"] == "message_stop"
+          stream_state = process_anthropic_stream_event(
+            data, accumulated_text, accumulated_tool_calls,
+            current_tool_call, current_tool_json, usage_data, finish_reason, block
+          )
+          current_tool_call = stream_state[:current_tool_call]
+          current_tool_json = stream_state[:current_tool_json]
+          finish_reason = stream_state[:finish_reason]
+        end
+
         response = with_transport_errors do
           conn.post("/v1/messages") do |req|
             req.headers["Content-Type"] = "application/json"
@@ -395,7 +397,7 @@ module RubyPi
           # Without this, Faraday buffers the entire response body before
           # returning, which means no deltas reach the caller until the model
           # finishes generating (fake streaming).
-          req.options.on_data = proc do |chunk, overall_received_bytes, env|
+          req.options.on_data = proc do |chunk, _overall_received_bytes, env|
             response_status ||= env&.status
 
             # If the HTTP status indicates an error, accumulate the body for
@@ -403,41 +405,11 @@ module RubyPi
             # calls on_data for error responses too, which would otherwise
             # consume the body and leave response.body empty.
             if response_status && response_status >= 400
-              error_body << chunk.b
+              append_error_body(error_body, chunk)
               next
             end
 
-            sse_buffer << chunk.b
-            # Process all complete lines in the buffer. A complete line holds
-            # complete UTF-8 sequences (multi-byte characters split across
-            # chunks are repaired by the buffering), so re-encode it to UTF-8
-            # here; scrub guards against a server sending invalid bytes.
-            while (line_end = sse_buffer.index("\n"))
-              line = sse_buffer.slice!(0, line_end + 1).force_encoding(Encoding::UTF_8).scrub.strip
-              next if line.empty?
-              next unless line.start_with?("data: ")
-
-              data_str = line.sub(/\Adata: /, "")
-              next if data_str == "[DONE]"
-
-              begin
-                data = JSON.parse(data_str)
-              rescue JSON::ParserError
-                next
-              end
-
-              # --- process each SSE event exactly as before ---
-              # Process the SSE event and update mutable locals from the
-              # returned hash. This keeps all streaming state method-local,
-              # avoiding thread-unsafe instance variables.
-              stream_state = process_anthropic_stream_event(
-                data, accumulated_text, accumulated_tool_calls,
-                current_tool_call, current_tool_json, usage_data, finish_reason, block
-              )
-              current_tool_call = stream_state[:current_tool_call]
-              current_tool_json = stream_state[:current_tool_json]
-              finish_reason = stream_state[:finish_reason]
-            end
+            sse_parser.feed(chunk, &process_payload)
           end
           end # conn.post
         end # with_transport_errors
@@ -452,25 +424,13 @@ module RubyPi
           handle_error_response(error_response, override_body: error_body_str)
         end
 
-        # Process any remaining data in the buffer after the connection closes
-        sse_buffer.force_encoding(Encoding::UTF_8).scrub.each_line do |line|
-          line = line.strip
-          next if line.empty?
-          next unless line.start_with?("data: ")
-          data_str = line.sub(/\Adata: /, "")
-          next if data_str == "[DONE]"
-          begin
-            data = JSON.parse(data_str)
-          rescue JSON::ParserError
-            next
-          end
-          stream_state = process_anthropic_stream_event(
-            data, accumulated_text, accumulated_tool_calls,
-            current_tool_call, current_tool_json, usage_data, finish_reason, block
+        sse_parser.finish(&process_payload)
+
+        unless stream_completed
+          raise RubyPi::StreamingProtocolError.new(
+            "anthropic stream ended before message_stop",
+            status_code: nil
           )
-          current_tool_call = stream_state[:current_tool_call]
-          current_tool_json = stream_state[:current_tool_json]
-          finish_reason = stream_state[:finish_reason]
         end
 
         # (Event processing is now handled incrementally by the on_data callback
@@ -532,11 +492,14 @@ module RubyPi
           delta = data["delta"] || {}
           if delta["type"] == "text_delta"
             text = delta["text"] || ""
-            accumulated_text << text
+            append_stream_data!(accumulated_text, text, limit: MAX_STREAM_OUTPUT_BYTES, label: "stream output")
             block.call(StreamEvent.new(type: :text_delta, data: text))
           elsif delta["type"] == "input_json_delta"
             json_chunk = delta["partial_json"] || ""
-            current_tool_json << json_chunk
+            append_stream_data!(
+              current_tool_json, json_chunk,
+              limit: MAX_STREAM_TOOL_ARGUMENT_BYTES, label: "tool arguments"
+            )
             block.call(StreamEvent.new(type: :tool_call_delta, data: {
               id: current_tool_call&.dig(:id),
               partial_json: json_chunk
@@ -554,11 +517,10 @@ module RubyPi
                         else
                           begin
                             JSON.parse(current_tool_json)
-                          rescue JSON::ParserError => e
+                          rescue JSON::ParserError
                             raise RubyPi::ProviderError.new(
                               "Failed to parse streaming tool call arguments for " \
-                              "'#{current_tool_call[:name]}': #{e.message} " \
-                              "(accumulated JSON: #{current_tool_json.inspect})",
+                              "'#{current_tool_call[:name]}'",
                               provider: :anthropic
                             )
                           end
@@ -568,6 +530,7 @@ module RubyPi
               name: current_tool_call[:name],
               arguments: arguments
             )
+            enforce_stream_tool_call_limit!(accumulated_tool_calls.size)
             current_tool_call = nil
             current_tool_json = +""
           end

data/lib/ruby_pi/llm/base_provider.rb

@@ -33,6 +33,11 @@ module RubyPi
     #     end
     #   end
     class BaseProvider
+      MAX_STREAM_OUTPUT_BYTES = 16 * 1024 * 1024
+      MAX_STREAM_TOOL_ARGUMENT_BYTES = 1024 * 1024
+      MAX_STREAM_TOOL_CALLS = 128
+      MAX_ERROR_BODY_BYTES = 64 * 1024
+      RETRY_AFTER_CEILING = 60.0
       # @return [Integer] maximum number of retry attempts
       attr_reader :max_retries
 
@@ -77,10 +82,12 @@ module RubyPi
       def complete(messages:, tools: [], stream: false, &block)
         attempt = 0
         partial_chars = 0
+        partial_tool_calls = false
 
         attempt_block = if stream && block
                           proc do |event|
                             partial_chars += event.data.to_s.length if event.text_delta?
+                            partial_tool_calls = true if event.tool_call_delta?
                             block.call(event)
                           end
                         else
@@ -117,10 +124,12 @@ module RubyPi
                 provider: provider_name,
                 error: e.message,
                 attempt: attempt + 1,
-                partial_output: partial_chars.positive?,
-                partial_chars: partial_chars
+                partial_output: partial_chars.positive? || partial_tool_calls,
+                partial_chars: partial_chars,
+                partial_tool_calls: partial_tool_calls
               }))
               partial_chars = 0
+              partial_tool_calls = false
             end
 
             sleep(delay)
@@ -151,6 +160,31 @@ module RubyPi
 
       private
 
+      def append_stream_data!(buffer, chunk, limit:, label:)
+        if buffer.bytesize + chunk.to_s.bytesize > limit
+          raise RubyPi::StreamingProtocolError.new(
+            "#{provider_name} #{label} exceeded #{limit} bytes",
+            status_code: nil
+          )
+        end
+
+        buffer << chunk
+      end
+
+      def append_error_body(error_body, chunk)
+        remaining = MAX_ERROR_BODY_BYTES - error_body.bytesize
+        error_body << chunk.to_s.b.byteslice(0, remaining) if remaining.positive?
+      end
+
+      def enforce_stream_tool_call_limit!(count)
+        return if count <= MAX_STREAM_TOOL_CALLS
+
+        raise RubyPi::StreamingProtocolError.new(
+          "#{provider_name} stream exceeded #{MAX_STREAM_TOOL_CALLS} tool calls",
+          status_code: nil
+        )
+      end
+
       # Performs the actual completion request. Subclasses MUST implement this
       # method with provider-specific HTTP logic.
       #
@@ -159,15 +193,10 @@ module RubyPi
       # @param stream [Boolean] streaming mode flag
       # @yield [event] optional block for streaming events
       # @return [RubyPi::LLM::Response]
-      def perform_complete(messages:, tools:, stream:, &block)
+      def perform_complete(...)
         raise RubyPi::AbstractMethodError, :perform_complete
       end
 
-      # Maximum delay (seconds) honored from a server-provided Retry-After
-      # header. Caps pathological or misconfigured server values so a single
-      # 429 cannot stall the client indefinitely.
-      RETRY_AFTER_CEILING = 60.0
-
       # Picks the delay before the next retry. A server-provided Retry-After
       # on a 429 takes precedence over the local exponential backoff: the
       # server knows its own cooldown window, and retrying earlier just burns

data/lib/ruby_pi/llm/fallback.rb

@@ -157,13 +157,17 @@ module RubyPi
         # carries partial_output/partial_chars so consumers can deterministically
         # truncate what they already rendered.
         partial_chars = 0
+        partial_tool_calls = false
         counting_block = proc do |event|
           if event.retry_start?
             # The provider tells consumers to discard its previous attempt,
             # so only count text from the current attempt for a later fallback.
             partial_chars = 0
+            partial_tool_calls = false
           elsif event.text_delta?
             partial_chars += event.data.to_s.length
+          elsif event.tool_call_delta?
+            partial_tool_calls = true
           end
           block.call(event)
         end
@@ -193,10 +197,11 @@ module RubyPi
           #                    this amount if appending to a shared buffer)
           block.call(StreamEvent.new(type: :fallback_start, data: {
             failed_provider: @primary.provider_name,
-            error: e.message,
+            error: safe_error_message(e),
             fallback_provider: @fallback.provider_name,
-            partial_output: partial_chars.positive?,
-            partial_chars: partial_chars
+            partial_output: partial_chars.positive? || partial_tool_calls,
+            partial_chars: partial_chars,
+            partial_tool_calls: partial_tool_calls
           }))
 
           # Stream directly from the fallback to the consumer's block.
@@ -219,10 +224,14 @@ module RubyPi
 
         logger.warn(
           "[RubyPi::Fallback] Primary provider (#{@primary.provider_name}/#{@primary.model_name}) " \
-          "failed with #{error.class}: #{error.message}. " \
+          "failed with #{error.class}: #{safe_error_message(error)}. " \
           "Falling back to #{@fallback.provider_name}/#{@fallback.model_name}."
         )
       end
+
+      def safe_error_message(error)
+        error.message.to_s.gsub(/[[:cntrl:]]+/, " ").slice(0, 512)
+      end
     end
   end
 end