phronomy 0.1.2 → 0.1.4

data/lib/phronomy/memory/storage/active_record.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "json"
-require "ostruct"
 
 module Phronomy
   module Memory
@@ -38,6 +37,10 @@ module Phronomy
       #     compaction_model_class: PhronomyCompaction
       #   )
       #   manager = Phronomy::Memory::ConversationManager.new(storage: storage, ...)
+      # Internal value object representing a loaded message record.
+      MessageStruct = Data.define(:role, :content, :tool_calls, :model_id)
+      private_constant :MessageStruct
+
       class ActiveRecord < Base
         # @param model_class            [Class]      AR model for the legacy load/save interface
         # @param raw_model_class        [Class, nil] AR model for raw message storage
@@ -55,7 +58,7 @@ module Phronomy
         # Load all messages for a thread, ordered by creation time.
         #
         # @param thread_id [String]
-        # @return [Array<OpenStruct>]
+        # @return [Array<MessageStruct>]
         def load(thread_id:)
           records = @model_class.where(thread_id: thread_id).order(:created_at).to_a
           records.map { |r| to_message_struct(r) }
@@ -72,7 +75,7 @@ module Phronomy
               @model_class.create!(
                 thread_id: thread_id,
                 role: msg.role.to_s,
-                content: msg.content.to_s,
+                content: msg.content,
                 tool_calls_json: serialize_tool_calls(msg),
                 model_id: (msg.model_id if msg.respond_to?(:model_id))
               )
@@ -97,15 +100,17 @@ module Phronomy
         def append_raw(thread_id:, messages:, starting_seq:)
           return unless @raw_model_class
 
-          messages.each_with_index do |msg, i|
-            @raw_model_class.create!(
-              thread_id: thread_id,
-              seq: starting_seq + i,
-              role: msg.role.to_s,
-              content: msg.content.to_s,
-              tool_calls_json: serialize_tool_calls(msg),
-              model_id: (msg.model_id if msg.respond_to?(:model_id))
-            )
+          @raw_model_class.transaction do
+            messages.each_with_index do |msg, i|
+              @raw_model_class.create!(
+                thread_id: thread_id,
+                seq: starting_seq + i,
+                role: msg.role.to_s,
+                content: msg.content,
+                tool_calls_json: serialize_tool_calls(msg),
+                model_id: (msg.model_id if msg.respond_to?(:model_id))
+              )
+            end
           end
         end
 
@@ -201,7 +206,7 @@ module Phronomy
               parsed
             end
           end
-          OpenStruct.new(
+          MessageStruct.new(
             role: record.role.to_sym,
             content: record.content,
             tool_calls: tool_calls,

data/lib/phronomy/memory/storage/in_memory.rb

@@ -11,6 +11,7 @@ module Phronomy
       #   manager = Phronomy::Memory::ConversationManager.new(storage: storage, ...)
       class InMemory < Base
         def initialize
+          @mutex = Mutex.new
           @store = {}
           @raw_store = {}       # thread_id => [{seq:, message:}, ...]
           @compaction_store = {} # thread_id => [{start_seq:, end_seq:, summary_text:}, ...]
@@ -23,20 +24,22 @@ module Phronomy
         # @param thread_id [String]
         # @return [Array]
         def load(thread_id:)
-          (@store[thread_id] || []).dup
+          @mutex.synchronize { (@store[thread_id] || []).dup }
         end
 
         # @param thread_id [String]
         # @param messages  [Array]
         def save(thread_id:, messages:)
-          @store[thread_id] = messages.dup
+          @mutex.synchronize { @store[thread_id] = messages.dup }
         end
 
         # @param thread_id [String]
         def clear(thread_id:)
-          @store.delete(thread_id)
-          clear_raw(thread_id: thread_id)
-          clear_compactions(thread_id: thread_id)
+          @mutex.synchronize do
+            @store.delete(thread_id)
+            @raw_store.delete(thread_id)
+            @compaction_store.delete(thread_id)
+          end
         end
 
         # -----------------------------------------------------------------------
@@ -48,21 +51,23 @@ module Phronomy
         # @param starting_seq [Integer]
         def append_raw(thread_id:, messages:, starting_seq:)
           now = Time.now
-          @raw_store[thread_id] ||= []
-          messages.each_with_index do |msg, i|
-            @raw_store[thread_id] << {seq: starting_seq + i, message: msg, recorded_at: now}
+          @mutex.synchronize do
+            @raw_store[thread_id] ||= []
+            messages.each_with_index do |msg, i|
+              @raw_store[thread_id] << {seq: starting_seq + i, message: msg, recorded_at: now}
+            end
           end
         end
 
         # @param thread_id [String]
         # @return [Array<Hash>]
         def load_raw(thread_id:)
-          (@raw_store[thread_id] || []).dup
+          @mutex.synchronize { (@raw_store[thread_id] || []).dup }
         end
 
         # @param thread_id [String]
         def clear_raw(thread_id:)
-          @raw_store.delete(thread_id)
+          @mutex.synchronize { @raw_store.delete(thread_id) }
         end
 
         # -----------------------------------------------------------------------
@@ -74,19 +79,21 @@ module Phronomy
         # @param end_seq      [Integer]
         # @param summary_text [String]
         def save_compaction(thread_id:, start_seq:, end_seq:, summary_text:)
-          @compaction_store[thread_id] ||= []
-          @compaction_store[thread_id] << {start_seq: start_seq, end_seq: end_seq, summary_text: summary_text}
+          @mutex.synchronize do
+            @compaction_store[thread_id] ||= []
+            @compaction_store[thread_id] << {start_seq: start_seq, end_seq: end_seq, summary_text: summary_text}
+          end
         end
 
         # @param thread_id [String]
         # @return [Array<Hash>]
         def load_compactions(thread_id:)
-          (@compaction_store[thread_id] || []).dup
+          @mutex.synchronize { (@compaction_store[thread_id] || []).dup }
         end
 
         # @param thread_id [String]
         def clear_compactions(thread_id:)
-          @compaction_store.delete(thread_id)
+          @mutex.synchronize { @compaction_store.delete(thread_id) }
         end
 
         # Remove raw messages recorded before +older_than+ for this thread.
@@ -94,9 +101,11 @@ module Phronomy
         # @param thread_id  [String]
         # @param older_than [Time]
         def purge_older_than(thread_id:, older_than:)
-          return unless @raw_store[thread_id]
+          @mutex.synchronize do
+            next unless @raw_store[thread_id]
 
-          @raw_store[thread_id].reject! { |entry| entry[:recorded_at] && entry[:recorded_at] < older_than }
+            @raw_store[thread_id].reject! { |entry| entry[:recorded_at] && entry[:recorded_at] < older_than }
+          end
         end
       end
     end

data/lib/phronomy/rails/agent_job.rb

@@ -25,6 +25,8 @@ module Phronomy
     class AgentJob < ::ActiveJob::Base
       # @param agent_class_name [String]
       #   The constantize-able class name of the agent to run (e.g. "MyAgent").
+      #   **Security**: only classes that are subclasses of +Phronomy::Agent::Base+
+      #   are accepted. Never pass a value derived from user-controlled input.
       # @param input [String, Hash]
       #   User input forwarded unchanged to the agent's +#stream+ method.
       # @param channel [String]
@@ -35,21 +37,36 @@ module Phronomy
       #   Configuration forwarded to the agent's +#stream+ call. Both symbol and
       #   string keys are accepted; all keys are converted to symbols before use.
       def perform(agent_class_name, input, channel:, stream:, config: {})
-        agent = Object.const_get(agent_class_name).new
+        klass = resolve_agent_class!(agent_class_name)
+        agent = klass.new
         agent.stream(input, config: config.transform_keys(&:to_sym)) do |event|
           ActionCable.server.broadcast(stream, build_payload(event))
         end
       rescue => e
-        ActionCable.server.broadcast(stream, {type: "error", message: e.message})
+        ::Rails.logger.error("[Phronomy::Rails::AgentJob] agent error (#{e.class}): #{e.message}")
+        ActionCable.server.broadcast(stream, {type: "error", message: "An error occurred while processing your request."})
       end
 
       private
 
+      # Resolves and validates the agent class name.
+      # Raises ArgumentError when the name does not resolve to a subclass of
+      # Phronomy::Agent::Base, preventing arbitrary class instantiation.
+      def resolve_agent_class!(class_name)
+        klass = Object.const_get(class_name.to_s)
+        unless klass.is_a?(Class) && klass < Phronomy::Agent::Base
+          raise ArgumentError, "#{class_name.inspect} is not a Phronomy::Agent::Base subclass"
+        end
+        klass
+      rescue NameError
+        raise ArgumentError, "Unknown agent class: #{class_name.inspect}"
+      end
+
       def build_payload(event)
         case event.type
         when :token then {type: "token", content: event.payload[:content]}
         when :done then {type: "done", output: event.payload[:output]}
-        when :error then {type: "error", message: event.payload[:error]&.message}
+        when :error then {type: "error", message: "An error occurred while processing your request."}
         else {type: event.type.to_s}
         end
       end

data/lib/phronomy/runnable.rb

@@ -28,7 +28,10 @@ module Phronomy
     # @example
     #   trace("my_chain", input: input) { [invoke(input), nil] }
     def trace(name, input: nil, **meta, &block)
-      Phronomy.configuration.tracer.trace(name, input: input, **meta, &block)
+      # Redact user input from spans when trace_pii is disabled to prevent
+      # accidental PII transmission to external tracing backends.
+      traced_input = Phronomy.configuration.trace_pii ? input : "[REDACTED]"
+      Phronomy.configuration.tracer.trace(name, input: traced_input, **meta, &block)
     end
   end
 end

data/lib/phronomy/state_store/active_record.rb

@@ -43,9 +43,13 @@ module Phronomy
       def save(state)
         json = serialize_state(state)
         payload = @encryptor ? @encryptor.encrypt(json) : json
-        record = @model_class.find_or_initialize_by(thread_id: state.thread_id)
-        record.state_json = payload
-        record.save!
+        # Use upsert to avoid a race condition where two concurrent saves for the
+        # same thread_id would both see "no record" and collide on the unique index.
+        @model_class.upsert(
+          {thread_id: state.thread_id, state_json: payload},
+          unique_by: :thread_id,
+          update_only: [:state_json]
+        )
         self
       end
 

data/lib/phronomy/state_store/base.rb

@@ -61,9 +61,23 @@ module Phronomy
       end
 
       # Resolves and validates a state class name.
-      # Raises ArgumentError if the name does not resolve to a class that
-      # includes Phronomy::Graph::State, preventing unsafe deserialization.
+      # When a registry has been configured via +Phronomy::Graph.register_state_class+,
+      # only registered classes are accepted — this prevents unintended autoloading
+      # of arbitrary files from an untrusted class name stored in Redis/DB.
+      # When no registry is configured, falls back to Object.const_get with a check
+      # that the resolved class includes Phronomy::Graph::State.
       def safe_state_class(class_name)
+        registry = Phronomy::Graph.state_class_registry
+        if registry
+          klass = registry[class_name.to_s]
+          unless klass
+            raise ArgumentError,
+              "Unregistered state class: #{class_name.inspect}. " \
+              "Call Phronomy::Graph.register_state_class(#{class_name}) at startup."
+          end
+          return klass
+        end
+
         klass = Object.const_get(class_name.to_s)
         unless klass.is_a?(Class) && klass.include?(Phronomy::Graph::State)
           raise ArgumentError, "Invalid state class: #{class_name.inspect}"

data/lib/phronomy/state_store/in_memory.rb

@@ -8,30 +8,31 @@ module Phronomy
     class InMemory < Base
       def initialize
         @store = {}
+        @mutex = Mutex.new
       end
 
       # @param state [Object] includes Phronomy::Graph::State; must have a non-nil thread_id
       # @return [self]
       def save(state)
-        @store[state.thread_id] = state
+        @mutex.synchronize { @store[state.thread_id] = state }
         self
       end
 
       # @param thread_id [String]
       # @return [Object, nil] state object or nil
       def load(thread_id)
-        @store[thread_id]
+        @mutex.synchronize { @store[thread_id] }
       end
 
       # @param thread_id [String]
       # @return [self]
       def clear(thread_id)
-        @store.delete(thread_id)
+        @mutex.synchronize { @store.delete(thread_id) }
         self
       end
 
       def clear_all
-        @store.clear
+        @mutex.synchronize { @store.clear }
         self
       end
     end

data/lib/phronomy/tool/base.rb

@@ -157,7 +157,14 @@ module Phronomy
           key = properties.key?(param_name.to_s) ? param_name.to_s : param_name.to_sym
           next unless properties[key]
 
-          properties[key]["enum"] = values.map(&:to_s)
+          param_type = properties[key]["type"]
+          properties[key]["enum"] = values.map do |v|
+            case param_type
+            when "integer" then v.is_a?(Integer) ? v : Integer(v.to_s)
+            when "number" then v.is_a?(Numeric) ? v : Float(v.to_s)
+            else v.to_s
+            end
+          end
         end
 
         schema
@@ -193,6 +200,11 @@ module Phronomy
         end
       end
 
+      # Instance method accessor — delegates to the class-level flag.
+      def requires_approval
+        self.class.requires_approval
+      end
+
       # Instance method for requires_approval? (convenience accessor).
       def requires_approval?
         self.class.requires_approval
@@ -276,11 +288,15 @@ module Phronomy
 
         self.class.parameters.each do |name, param|
           value = normalized[name]
-          next if value.nil? && !param.required
+          if value.nil?
+            # Return a descriptive error for missing required params so the LLM
+            # can self-correct on the next turn.
+            return [nil, "required parameter '#{name}' is missing"] if param.required
+            next
+          end
 
           if coerce_mode
             coerced, error = coerce_value(value, param.type)
-            return [nil, error] if error && !coerce_mode
             return [nil, error] if error
             value = coerced
           else

data/lib/phronomy/tool/mcp_tool.rb

@@ -79,12 +79,38 @@ module Phronomy
       # -----------------------------------------------------------------------
 
       # Minimal stdio transport implementing a subset of the MCP JSON-RPC protocol.
-      # Spawns the server command as a child process and communicates line-by-line.
+      # Keeps the child process alive for the lifetime of this transport instance
+      # so that session state (registered resources, tool context, etc.) is preserved
+      # across multiple calls.
       class StdioTransport
         def initialize(command)
           # Split the command string into an argv array so that Open3 executes
           # it directly without going through the shell, preventing injection.
           @command = Shellwords.split(command)
+          @mutex = Mutex.new
+          @stdin = nil
+          @stdout = nil
+          @stderr = nil
+          @wait_thr = nil
+          @stderr_thread = nil
+        end
+
+        # Shut down the child process and close its IO streams.
+        def close
+          @mutex.synchronize do
+            @stdin&.close
+            @stdout&.close
+            @stderr&.close
+            @stdin = nil
+            @stdout = nil
+            @stderr = nil
+          end
+          # Join the stderr drain thread and the child process outside the mutex
+          # to avoid holding the lock during potentially slow joins.
+          @stderr_thread&.join(1)
+          @wait_thr&.join(5)
+          @stderr_thread = nil
+          @wait_thr = nil
         end
 
         # Retrieve the tool definition from the server using the MCP `tools/list` method.
@@ -108,6 +134,10 @@ module Phronomy
         # @return [Object] the tool result
         def call_tool(tool_name, args)
           response = rpc_call("tools/call", {name: tool_name, arguments: args})
+          if response["error"]
+            err_msg = response.dig("error", "message") || response["error"].to_s
+            raise Phronomy::ToolError, "MCP server returned error: #{err_msg}"
+          end
           content = response.dig("result", "content")
 
           # MCP content is an array of content blocks; extract text blocks.
@@ -121,12 +151,30 @@ module Phronomy
 
         private
 
-        def rpc_call(method, params)
-          payload = JSON.generate(jsonrpc: "2.0", id: 1, method: method, params: params)
-          stdout, _stderr, status = Open3.capture3(*@command, stdin_data: "#{payload}\n")
-          raise Phronomy::ToolError, "MCP server exited with status #{status.exitstatus}" unless status.success?
+        # Ensure the child process is running, spawning it if necessary.
+        def ensure_started!
+          return if @stdin && !@stdin.closed?
+
+          @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(*@command)
+          # Drain stderr asynchronously to prevent the pipe buffer from filling
+          # and deadlocking the child process. Errors inside the drain thread are
+          # silently ignored since stderr content is diagnostics-only.
+          @stderr_thread = Thread.new do
+            @stderr.read
+          rescue
+            nil
+          end
+        end
 
-          JSON.parse(stdout.lines.first.to_s)
+        def rpc_call(method, params)
+          @mutex.synchronize do
+            ensure_started!
+            payload = JSON.generate(jsonrpc: "2.0", id: SecureRandom.uuid, method: method, params: params)
+            @stdin.puts(payload)
+            raw = @stdout.gets
+            raise Phronomy::ToolError, "MCP server closed the connection unexpectedly" if raw.nil?
+            JSON.parse(raw)
+          end
         end
 
         def parse_schema_params(properties)
@@ -153,9 +201,13 @@ module Phronomy
       #     tool_name: "weather_lookup"
       #   )
       class HttpTransport
-        # @param base_url [String] full URL of the MCP endpoint, e.g. "http://localhost:8080/mcp"
-        def initialize(base_url)
+        # @param base_url     [String]  full URL of the MCP endpoint, e.g. "http://localhost:8080/mcp"
+        # @param open_timeout [Integer] TCP connection timeout in seconds (default: 5)
+        # @param read_timeout [Integer] HTTP read timeout in seconds (default: 30)
+        def initialize(base_url, open_timeout: 5, read_timeout: 30)
           @uri = URI.parse(base_url)
+          @open_timeout = open_timeout
+          @read_timeout = read_timeout
         end
 
         # Retrieve the tool definition from the server using MCP `tools/list`.
@@ -179,6 +231,10 @@ module Phronomy
         # @return [Object] the tool result
         def call_tool(tool_name, args)
           response = rpc_call("tools/call", {name: tool_name, arguments: args})
+          if response["error"]
+            err_msg = response.dig("error", "message") || response["error"].to_s
+            raise Phronomy::ToolError, "MCP HTTP server returned error: #{err_msg}"
+          end
           content = response.dig("result", "content")
 
           if content.is_a?(Array)
@@ -192,10 +248,12 @@ module Phronomy
         private
 
         def rpc_call(method, params)
-          payload = JSON.generate(jsonrpc: "2.0", id: 1, method: method, params: params)
+          payload = JSON.generate(jsonrpc: "2.0", id: SecureRandom.uuid, method: method, params: params)
 
           http = Net::HTTP.new(@uri.host, @uri.port)
           http.use_ssl = (@uri.scheme == "https")
+          http.open_timeout = @open_timeout
+          http.read_timeout = @read_timeout
 
           path = @uri.path.empty? ? "/" : @uri.path
           path = "#{path}?#{@uri.query}" if @uri.query

data/lib/phronomy/tracing/base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ostruct"
-
 module Phronomy
   module Tracing
     # Abstract tracer.

data/lib/phronomy/tracing/langfuse_tracer.rb

@@ -35,6 +35,8 @@ module Phronomy
         @public_key = public_key
         @secret_key = secret_key
         @host = host.chomp("/")
+        @http = nil
+        @http_mutex = Mutex.new
       end
 
       # Returns a plain Hash that records the span start state.
@@ -78,19 +80,37 @@ module Phronomy
       private
 
       # Sends a batch of events to the Langfuse ingestion endpoint.
+      # The Net::HTTP connection is cached and reused across calls to avoid
+      # per-span TCP + TLS handshake overhead (Issue #61).
       # Errors are rescued and ignored to keep the tracer non-disruptive.
       def ingest(events)
         uri = URI.parse("#{@host}/api/public/ingestion")
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == "https")
         req = Net::HTTP::Post.new(uri.request_uri)
         req["Content-Type"] = "application/json"
         req["Authorization"] = "Basic #{Base64.strict_encode64("#{@public_key}:#{@secret_key}")}"
         req.body = JSON.generate({batch: events})
-        http.request(req)
-      rescue
+
+        @http_mutex.synchronize do
+          @http ||= build_http(uri)
+          @http.request(req)
+        end
+      rescue IOError, Errno::ECONNRESET, Errno::EPIPE => e
+        # Connection was reset; drop the cached connection and warn.
+        @http_mutex.synchronize { @http = nil }
+        warn "[Phronomy::LangfuseTracer] Ingestion failed: #{e.class}: #{e.message}"
+        nil
+      rescue => e
+        warn "[Phronomy::LangfuseTracer] Ingestion failed: #{e.class}: #{e.message}"
         nil
       end
+
+      def build_http(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = 3
+        http.read_timeout = 5
+        http
+      end
     end
   end
 end

data/lib/phronomy/tracing/null_tracer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ostruct"
-
 module Phronomy
   module Tracing
     # No-op tracer used as the default. All calls succeed silently.
@@ -10,8 +8,13 @@ module Phronomy
     #
     #   Phronomy.configure { |c| c.tracer = MyRealTracer.new }
     class NullTracer < Base
+      # Internal value object for span handles returned by #start_span.
+      # Uses Struct (not OpenStruct) so that unknown attribute access raises NoMethodError.
+      SpanStruct = Struct.new(:name)
+      private_constant :SpanStruct
+
       # Returns a minimal span object with the given name.
-      def start_span(name, **) = OpenStruct.new(name: name)
+      def start_span(name, **) = SpanStruct.new(name)
 
       # Does nothing.
       def finish_span(span, **) = nil

data/lib/phronomy/trust_pipeline.rb

@@ -75,13 +75,22 @@ module Phronomy
     # @param review_agent         [Class]   subclass of Phronomy::Agent::Base
     # @param confidence_threshold [Float]   answers below this are retried (default: 0.7)
     # @param max_iterations       [Integer] maximum draft-review cycles (default: 3)
+    # @param input_delimiter      [Array<String>, nil] optional two-element array
+    #   [start_tag, end_tag] used to wrap user input in prompts, e.g.
+    #   ["<user_input>", "</user_input>"] or
+    #   ["=== user input start ===", "=== user input end ==="].
+    #   When nil (default), input is embedded as-is for backward compatibility.
     def initialize(draft_agent:, review_agent:,
       confidence_threshold: DEFAULT_CONFIDENCE_THRESHOLD,
-      max_iterations: DEFAULT_MAX_ITERATIONS)
+      max_iterations: DEFAULT_MAX_ITERATIONS,
+      input_delimiter: nil)
       @draft_agent_class = draft_agent
       @review_agent_class = review_agent
       @threshold = confidence_threshold.to_f
       @max_iterations = max_iterations.to_i
+      @input_delimiter = input_delimiter
+      @graph_mutex = Mutex.new
+      @compiled_graph = nil
     end
 
     # Run the pipeline.
@@ -90,7 +99,7 @@ module Phronomy
     # @param config [Hash]   forwarded to the underlying agents (e.g. thread_id)
     # @return [Result]
     def invoke(input, config: {})
-      app = build_graph.compile
+      app = compiled_graph
       state = app.invoke({input: input}, config: config)
       confidence = combined_confidence(state)
       Result.new(
@@ -109,6 +118,16 @@ module Phronomy
       [(state.self_score || 0.0).to_f, (state.review_score || 0.0).to_f].min
     end
 
+    # Returns the compiled graph, building and caching it on first call.
+    # Thread-safe via double-checked locking.
+    def compiled_graph
+      return @compiled_graph if @compiled_graph
+
+      @graph_mutex.synchronize do
+        @compiled_graph ||= build_graph.compile
+      end
+    end
+
     def build_graph
       draft_agent = @draft_agent_class.new
       review_agent = @review_agent_class.new
@@ -161,6 +180,15 @@ module Phronomy
       graph
     end
 
+    # Wraps +input+ with the configured delimiter pair when +input_delimiter+ is set.
+    # When no delimiter is configured the input is returned unchanged.
+    def wrap_input(input)
+      return input unless @input_delimiter
+
+      start_tag, end_tag = @input_delimiter
+      "#{start_tag}\n#{input}\n#{end_tag}"
+    end
+
     # Builds the prompt sent to the DraftAgent for each iteration.
     def draft_prompt(input, feedback)
       lines = [
@@ -174,7 +202,7 @@ module Phronomy
       end
       lines += [
         "",
-        "Question: #{input}",
+        "Question: #{wrap_input(input)}",
         "",
         "RESPOND ONLY WITH VALID JSON (no text outside the JSON block):",
         '{"answer":"<full answer>","confidence":<0.0-1.0>,' \
@@ -193,7 +221,7 @@ module Phronomy
       [
         "You are a rigorous quality reviewer. Evaluate the draft answer below.",
         "",
-        "Question: #{input}",
+        "Question: #{wrap_input(input)}",
         "",
         "Draft answer:",
         draft.to_s,