phronomy 0.16.0 → 0.18.0

data/lib/phronomy/agent/tool_invocation_session_builder.rb

@@ -5,18 +5,9 @@ require "state_machines"
 module Phronomy
   module Agent
     # Builds an FSMSession for one ToolInvocation.
-    #
-    # Authorization and execution Tasks are observed by ToolInvocation-specific
-    # callbacks that post explicit FSM events. The generated phase machine does
-    # not await Tasks.
-    #
-    # @api private
+    # Async completion is represented only by explicit FSM events.
     class ToolInvocationSessionBuilder
-      AUTO_STATE_SET = {
-        idle: true,
-        validating: true,
-        queued: true
-      }.freeze
+      AUTO_STATE_SET = {idle: true, validating: true, queued: true}.freeze
 
       DECLARED_STATES = %i[
         idle validating authorizing awaiting_approval authorized queued running
@@ -27,42 +18,20 @@ module Phronomy
 
       EXTERNAL_EVENTS = {
         authorization_completed: [
-          {from: :authorizing, to: :cancelled, guard: ->(ctx) {
-            ctx.cancelled?
-          }},
-          {from: :authorizing, to: :failed, guard: ->(ctx) {
-            ctx.failed?
-          }},
-          {from: :authorizing, to: :rejected, guard: ->(ctx) {
-            ctx.rejected?
-          }},
-          {from: :authorizing, to: :awaiting_approval, guard: ->(ctx) {
-            ctx.awaiting_approval?
-          }},
-          {from: :authorizing, to: :authorized, guard: ->(ctx) {
-            ctx.authorized?
-          }}
+          {from: :authorizing, to: :cancelled, guard: ->(ctx) { ctx.cancelled? }},
+          {from: :authorizing, to: :failed, guard: ->(ctx) { ctx.failed? }},
+          {from: :authorizing, to: :rejected, guard: ->(ctx) { ctx.rejected? }},
+          {from: :authorizing, to: :awaiting_approval, guard: ->(ctx) { ctx.awaiting_approval? }},
+          {from: :authorizing, to: :authorized, guard: ->(ctx) { ctx.authorized? }}
         ],
         execution_completed: [
-          {from: :running, to: :cancelled, guard: ->(ctx) {
-            ctx.cancelled?
-          }},
-          {from: :running, to: :failed, guard: ->(ctx) {
-            ctx.failed?
-          }},
-          {from: :running, to: :completed, guard: ->(ctx) {
-            ctx.execution_completed?
-          }}
-        ],
-        approve: [
-          {from: :awaiting_approval, to: :authorized, guard: nil}
-        ],
-        reject: [
-          {from: :awaiting_approval, to: :rejected, guard: nil}
-        ],
-        dispatch: [
-          {from: :authorized, to: :queued, guard: nil}
+          {from: :running, to: :cancelled, guard: ->(ctx) { ctx.cancelled? }},
+          {from: :running, to: :failed, guard: ->(ctx) { ctx.failed? }},
+          {from: :running, to: :completed, guard: ->(ctx) { ctx.execution_completed? }}
         ],
+        approve: [{from: :awaiting_approval, to: :authorized, guard: nil}],
+        reject: [{from: :awaiting_approval, to: :rejected, guard: nil}],
+        dispatch: [{from: :authorized, to: :queued, guard: nil}],
         cancel: [
           {from: :awaiting_approval, to: :cancelled, guard: nil},
           {from: :authorized, to: :cancelled, guard: nil},
@@ -71,14 +40,8 @@ module Phronomy
         ]
       }.freeze
 
-      def self.build(
-        tool_invocation:,
-        runtime: Phronomy::Runtime.instance
-      )
-        build_session(
-          tool_invocation: tool_invocation,
-          runtime: runtime
-        )
+      def self.build(tool_invocation:, runtime: Phronomy::Runtime.instance)
+        build_session(tool_invocation: tool_invocation, runtime: runtime)
       end
 
       def self.build_for_resume(
@@ -125,31 +88,15 @@ module Phronomy
       def self.build_entry_actions(runtime)
         {
           validating: [method(:validating_action)],
-          authorizing: [
-            method(:authorizing_action).curry.call(runtime)
-          ],
-          awaiting_approval: [
-            method(:awaiting_approval_action).curry.call(runtime)
-          ],
-          authorized: [
-            method(:authorized_action).curry.call(runtime)
-          ],
+          authorizing: [method(:authorizing_action).curry.call(runtime)],
+          awaiting_approval: [method(:awaiting_approval_action).curry.call(runtime)],
+          authorized: [method(:authorized_action).curry.call(runtime)],
           queued: [method(:queued_action)],
-          running: [
-            method(:running_action).curry.call(runtime)
-          ],
-          completed: [
-            method(:completed_action).curry.call(runtime)
-          ],
-          failed: [
-            method(:failed_action).curry.call(runtime)
-          ],
-          rejected: [
-            method(:rejected_action).curry.call(runtime)
-          ],
-          cancelled: [
-            method(:cancelled_action).curry.call(runtime)
-          ]
+          running: [method(:running_action).curry.call(runtime)],
+          completed: [method(:completed_action).curry.call(runtime)],
+          failed: [method(:failed_action).curry.call(runtime)],
+          rejected: [method(:rejected_action).curry.call(runtime)],
+          cancelled: [method(:cancelled_action).curry.call(runtime)]
         }
       end
       private_class_method :build_entry_actions
@@ -176,59 +123,29 @@ module Phronomy
 
             event :state_completed do
               transition idle: :validating
-
-              transition validating: :failed,
-                if: ->(machine) { machine.context&.failed? }
-              transition validating: :completed,
-                if: ->(machine) {
-                  machine.context&.validation_completed?
-                }
-              transition validating: :authorizing,
-                if: ->(machine) {
-                  machine.context&.validation_passed?
-                }
-
+              transition validating: :failed, if: ->(m) { m.context&.failed? }
+              transition validating: :completed, if: ->(m) { m.context&.validation_completed? }
+              transition validating: :authorizing, if: ->(m) { m.context&.validation_passed? }
               transition queued: :running
             end
 
             event :authorization_completed do
-              transition authorizing: :cancelled,
-                if: ->(machine) { machine.context&.cancelled? }
-              transition authorizing: :failed,
-                if: ->(machine) { machine.context&.failed? }
-              transition authorizing: :rejected,
-                if: ->(machine) { machine.context&.rejected? }
-              transition authorizing: :awaiting_approval,
-                if: ->(machine) {
-                  machine.context&.awaiting_approval?
-                }
-              transition authorizing: :authorized,
-                if: ->(machine) { machine.context&.authorized? }
+              transition authorizing: :cancelled, if: ->(m) { m.context&.cancelled? }
+              transition authorizing: :failed, if: ->(m) { m.context&.failed? }
+              transition authorizing: :rejected, if: ->(m) { m.context&.rejected? }
+              transition authorizing: :awaiting_approval, if: ->(m) { m.context&.awaiting_approval? }
+              transition authorizing: :authorized, if: ->(m) { m.context&.authorized? }
             end
 
             event :execution_completed do
-              transition running: :cancelled,
-                if: ->(machine) { machine.context&.cancelled? }
-              transition running: :failed,
-                if: ->(machine) { machine.context&.failed? }
-              transition running: :completed,
-                if: ->(machine) {
-                  machine.context&.execution_completed?
-                }
-            end
-
-            event :approve do
-              transition awaiting_approval: :authorized
-            end
-
-            event :reject do
-              transition awaiting_approval: :rejected
-            end
-
-            event :dispatch do
-              transition authorized: :queued
+              transition running: :cancelled, if: ->(m) { m.context&.cancelled? }
+              transition running: :failed, if: ->(m) { m.context&.failed? }
+              transition running: :completed, if: ->(m) { m.context&.execution_completed? }
             end
 
+            event(:approve) { transition awaiting_approval: :authorized }
+            event(:reject) { transition awaiting_approval: :rejected }
+            event(:dispatch) { transition authorized: :queued }
             event :cancel do
               transition awaiting_approval: :cancelled
               transition authorized: :cancelled
@@ -267,13 +184,9 @@ module Phronomy
       private_class_method :validating_action
 
       def self.authorizing_action(runtime, invocation)
-        task = invocation.authorization_task(runtime: runtime)
-        observe_task(
-          runtime,
-          invocation,
-          task,
-          event_type: :authorization_completed
-        )
+        invocation.start_authorization(runtime: runtime) do |outcome|
+          post_to_invocation(runtime, invocation.id, :authorization_completed, outcome)
+        end
         invocation
       end
       private_class_method :authorizing_action
@@ -298,45 +211,14 @@ module Phronomy
       private_class_method :queued_action
 
       def self.running_action(runtime, invocation)
-        # execution_task checks dispatchable? which requires :queued status;
-        # mark_running! is deferred until after the task is started.
-        task = invocation.execution_task(runtime: runtime)
+        invocation.start_execution(runtime: runtime) do |outcome|
+          post_to_invocation(runtime, invocation.id, :execution_completed, outcome)
+        end
         invocation.mark_running!
-        observe_task(
-          runtime,
-          invocation,
-          task,
-          event_type: :execution_completed
-        )
         invocation
       end
       private_class_method :running_action
 
-      def self.observe_task(
-        runtime,
-        invocation,
-        task,
-        event_type:
-      )
-        task.on_complete do |outcome, error|
-          payload = error || outcome
-          accepted = runtime.event_loop.post_to_session(
-            Phronomy::Event.new(
-              type: event_type,
-              target_id: invocation.id,
-              payload: payload
-            )
-          )
-          next if accepted
-
-          Phronomy.configuration.logger&.warn(
-            "[Phronomy] Dropped #{event_type.inspect} for " \
-            "ToolInvocation #{invocation.id}"
-          )
-        end
-      end
-      private_class_method :observe_task
-
       def self.completed_action(runtime, invocation)
         notify_parent(runtime, invocation, :tool_completed)
         invocation
@@ -363,6 +245,18 @@ module Phronomy
       end
       private_class_method :cancelled_action
 
+      def self.post_to_invocation(runtime, id, event_type, payload)
+        accepted = runtime.event_loop.post_to_session(
+          Phronomy::Event.new(type: event_type, target_id: id, payload: payload)
+        )
+        return if accepted
+
+        Phronomy.configuration.logger&.warn(
+          "[Phronomy] Dropped #{event_type.inspect} for ToolInvocation #{id}"
+        )
+      end
+      private_class_method :post_to_invocation
+
       def self.notify_parent(runtime, invocation, event_type)
         runtime.event_loop.post_to_session(
           Phronomy::Event.new(

data/lib/phronomy/agent.rb

@@ -4,24 +4,20 @@ module Phronomy
   module Agent
     StreamEvent = Data.define(:type, :payload)
 
-    def self.run_once(definition:, input:, context: nil, **invoke_options)
+    def self.run_once(definition:, input:, context: nil, knowledge: [], **invoke_options)
       persistence = Phronomy::Persistence::InMemory.new
-      agent = definition.create(context: context, persistence: persistence)
+      agent = definition.create(
+        context: context,
+        knowledge: knowledge,
+        persistence: persistence
+      )
       agent.invoke(input, **invoke_options)
     end
   end
 end
 
-require_relative "agent/fsm_runtime_adapter"
 require_relative "agent/async_event_api"
 
-unless Phronomy::Agent::AgentInvocationSessionBuilder.singleton_class <
-    Phronomy::Agent::FsmRuntimeAdapter
-  Phronomy::Agent::AgentInvocationSessionBuilder.singleton_class.prepend(
-    Phronomy::Agent::FsmRuntimeAdapter
-  )
-end
-
 unless Phronomy::Agent::Base < Phronomy::Agent::AsyncEventApi
   Phronomy::Agent::Base.prepend(Phronomy::Agent::AsyncEventApi)
 end

data/lib/phronomy/configuration.rb

@@ -2,194 +2,32 @@
 
 module Phronomy
   # Holds global configuration for the entire framework.
-  # Configure via the Phronomy.configure block.
-  #
-  # @example
-  #   Phronomy.configure do |config|
-  #     config.default_model    = "claude-3-5-sonnet-20241022"
-  #     config.recursion_limit  = 50
-  #   end
   class Configuration
     STREAM_CALLBACK_ERROR_POLICIES = %i[report fail_task].freeze
     private_constant :STREAM_CALLBACK_ERROR_POLICIES
 
-    # Default LLM model name (nil delegates to RubyLLM default)
     attr_accessor :default_model
-
-    # Default embedding model name
     attr_accessor :default_embedding_model
-
-    # Tracer instance
     attr_accessor :tracer
-
-    # Global before_llm_input hook callable (Proc / lambda).
-    # Called before every LLM request across all agents.
-    # Receives a {Phronomy::Agent::LLMInputBuildContext}; must return a
-    # {Phronomy::Agent::LLMInputPatch} or nil to pass through unchanged.
     attr_accessor :before_llm_input
-
-    # Default output token reservation when an agent does not set max_output_tokens
-    # and the model registry value equals the context window (making it unusable
-    # as a per-request output reserve). Integer or nil.
     attr_accessor :default_output_reserve
-
-    # Recursion limit for graph execution (default: 25)
     attr_accessor :recursion_limit
-
-    # When true, agent LLM calls use {Phronomy::MultiAgent::ParallelToolChat}
-    # for concurrent tool dispatch within a single agent turn.
-    # Defaults to false.
-    #
-    # Previously, this was automatically enabled when +event_loop+ was true.
-    # As of Phase 3, +parallel_tool_execution+ is a separate setting that must
-    # be explicitly enabled.
-    # @example
-    #   Phronomy.configure { |c| c.parallel_tool_execution = true }
-    # @return [Boolean]
     attr_accessor :parallel_tool_execution
-
-    # When true, user input and LLM output are recorded in trace spans.
-    # Defaults to false; set to true only in environments where PII capture is acceptable.
-    # Set to false in privacy-sensitive environments to prevent PII from reaching
-    # the tracing backend (OTel, Langfuse, etc.).
     attr_accessor :trace_pii
-
-    # Optional logger for framework diagnostic messages (e.g. unreachable-state warnings).
-    # Must respond to +#warn(message)+.  When nil (default), messages are written to +$stderr+
-    # via +Kernel#warn+.
-    # @example
-    #   Phronomy.configure { |c| c.logger = Rails.logger }
     attr_accessor :logger
-
-    # Grace period (in seconds) before the EventLoop background thread is force-killed
-    # after a cooperative stop request.  Applies both to the overall thread join
-    # and to the drain-and-cancel phase when +stop(drain: true)+ is used.
-    # Default: 5 seconds.
-    # @see Phronomy::EventLoop#stop
     attr_accessor :event_loop_stop_grace_seconds
-
-    # Global state store for workflow persistence.
-    # When set, WorkflowRunner routes all state reads and writes through this store.
-    # Must be an instance of a class that inherits from Phronomy::StateStore::Base.
-    # Defaults to +nil+ (no persistence — state lives only for the duration of invoke).
-    # @example
-    #   Phronomy.configure { |c| c.state_store = Phronomy::StateStore::InMemory.new }
     attr_accessor :state_store
-
-    # Maximum byte length of a tool result returned to the LLM.
-    # When a tool returns a String longer than this limit, the string is truncated
-    # and a warning is logged.  Set to +nil+ (default) to disable truncation.
-    # @example
-    #   Phronomy.configure { |c| c.tool_result_max_size = 8192 }
     attr_accessor :tool_result_max_size
-
-    # LLM adapter used by Agent::Base to perform LLM calls.
-    # Must be an instance of a class that inherits from
-    # {Phronomy::LLMAdapter::Base}.  Defaults to
-    # {Phronomy::LLMAdapter::RubyLLM} which delegates to +chat.ask+ via
-    # {BlockingAdapterPool}.
-    # Set to a custom adapter to swap in an alternative LLM client without
-    # changing any agent code.
-    # @example
-    #   Phronomy.configure { |c| c.llm_adapter = MyAsyncLLMAdapter.new }
     attr_accessor :llm_adapter
-
-    # Set to +nil+ to disable the warning.
-    # @return [Numeric, nil]
     attr_accessor :event_loop_starvation_threshold_seconds
-
-    # Warn when processing a single event on the EventLoop thread takes longer
-    # than this many seconds (long-running task / blocking-on-loop detection).
-    # Set to +nil+ to disable the warning.
-    # @return [Numeric, nil]
     attr_accessor :event_loop_dispatch_threshold_seconds
-
-    # When true, enables all blocking operation diagnostics (Issue #279).
-    # Equivalent to setting all diagnostic thresholds to their defaults.
-    # @return [Boolean]
-    attr_accessor :scheduler_debug
-
-    # Wall-clock threshold (milliseconds) after which a task that has not
-    # yielded the scheduler emits a warning log.  nil disables the check.
-    # @return [Float, nil]
-    attr_accessor :blocking_detect_threshold_ms
-
-    # Determines how an unhandled Application exception from a terminal stream
-    # callback affects the Task returned by Agent#stream_async or
-    # Agent#approve_async.
-    #
-    # +:report+ logs the callback failure and preserves the Agent result.
-    # +:fail_task+ logs the callback failure and fails the current Task with
-    # {Phronomy::StreamCallbackError}. Neither policy terminates EventLoop.
-    #
-    # Default: +:report+.
-    # @return [:report, :fail_task]
     attr_reader :stream_callback_error_policy
-
-    # Number of OS worker threads in the default {BlockingAdapterPool}.
-    # All LLM calls, MCP tool calls, and other blocking I/O share this pool.
-    # Increase for higher LLM/tool throughput; decrease to limit
-    # concurrency (e.g. to stay within a provider's rate limit).
-    # Default: 10.
-    # @return [Integer]
-    attr_accessor :blocking_io_pool_size
-
-    # Maximum number of operations that may wait in the {BlockingAdapterPool}
-    # queue before {Phronomy::BackpressureError} is raised (on_full: :raise) or
-    # the caller blocks (on_full: :wait, the default). Default: 100.
-    # @return [Integer]
-    attr_accessor :blocking_io_queue_size
-
-    # Worker count for Tool authorization evaluation. The named pool is owned
-    # by Runtime#pool(:authorization) and shares PoolRegistry lifecycle.
-    # @return [Integer]
+    attr_accessor :offload_pool_size
+    attr_accessor :offload_queue_size
     attr_accessor :authorization_pool_size
-
-    # Maximum queued Tool authorization evaluations.
-    # @return [Integer]
     attr_accessor :authorization_queue_size
-
-    # Operation-wide deadline for approval_facts, requires_approval callables,
-    # and Agent#tool_approval_policy. Timeout fails closed to Human approval.
-    # @return [Numeric]
     attr_accessor :authorization_timeout
 
-    # Scheduler starvation threshold (milliseconds).
-    # When a task waits more than this many milliseconds after calling
-    # +runtime.yield+ before being resumed, the wait is counted as a starvation
-    # event.  Used by the fairness regression test and by the
-    # +tasks_waiting_over_threshold+ metric on {Phronomy::Runtime}.
-    # Default: 50ms.
-    # @return [Numeric]
-    attr_accessor :starvation_threshold_ms
-
-    # Scheduler backend to use for new {Phronomy::Runtime} instances.
-    #
-    # | Value | Scheduler | Typical use |
-    # |-------|-----------|-------------|
-    # | +:thread+ | {Runtime::ThreadScheduler} | **Default** — production-ready; one OS thread per task |
-    # | +:immediate+ | {Runtime::FakeScheduler} | Tests — tasks run synchronously, no extra threads |
-    # | +:fiber+ | {Runtime::DeterministicScheduler} (autorun) | **EXPERIMENTAL** — Fiber-based cooperative scheduler; do not use as production default |
-    # | +:cooperative+ | {Runtime::FakeScheduler} | **Deprecated** — alias for +:immediate+; do not use in new code |
-    #
-    # The default is +:thread+. The +:fiber+ backend remains experimental and opt-in;
-    # it will not become the default until integration test coverage is production grade
-    # and virtual-time/timeout semantics are fully resolved (see Issues #350, #347, #348).
-    #
-    # When this setting is changed, the change only takes effect on the NEXT
-    # call to {Runtime.instance} that auto-creates a new instance (i.e. after the
-    # previous instance has been replaced or reset).  To replace the current
-    # instance immediately call +Phronomy::Runtime.instance = nil+ first.
-    #
-    # @return [:thread, :immediate, :fiber]
-    attr_accessor :runtime_backend
-
-    # When +true+, calling {Agent#invoke} from inside a scheduler task
-    # raises {SchedulerReentrancyError}.  When +false+ (default), a warning
-    # is logged instead so that existing callers have time to migrate.
-    # @return [Boolean]
-    attr_accessor :strict_runtime_guards
-
     def stream_callback_error_policy=(value)
       unless STREAM_CALLBACK_ERROR_POLICIES.include?(value)
         allowed = STREAM_CALLBACK_ERROR_POLICIES.map(&:inspect).join(", ")
@@ -209,17 +47,12 @@ module Phronomy
       @llm_adapter = Phronomy::LLMAdapter::RubyLLM.new
       @event_loop_starvation_threshold_seconds = nil
       @event_loop_dispatch_threshold_seconds = nil
-      @scheduler_debug = false
-      @blocking_detect_threshold_ms = nil
       @stream_callback_error_policy = :report
-      @blocking_io_pool_size = 10
-      @blocking_io_queue_size = 100
+      @offload_pool_size = 10
+      @offload_queue_size = 100
       @authorization_pool_size = 4
       @authorization_queue_size = 100
       @authorization_timeout = 5
-      @starvation_threshold_ms = 50
-      @runtime_backend = :thread
-      @strict_runtime_guards = false
     end
   end
 end

data/lib/phronomy/diagnostics.rb

@@ -1,62 +1,33 @@
 # frozen_string_literal: true
 
 module Phronomy
-  # Developer-facing diagnostics for blocking operation detection (Issue #279).
-  #
-  # Provides debug dump utilities that can be called from an IRB / Rails console
-  # or in test helpers to inspect the current state of the Runtime.
-  #
-  # @example Enable diagnostics and print a dump
-  #   Phronomy.configure { |c| c.scheduler_debug = true }
-  #   Phronomy::Diagnostics.dump
+  # Developer-facing diagnostics for EventLoop and offload execution boundaries.
   module Diagnostics
-    # Prints a formatted summary of the current Runtime state to +$stderr+
-    # (or the supplied IO).
-    #
-    # Includes:
-    # - BlockingAdapterPool: active workers, queue depth, abandoned count
-    # - EventLoop: last / max / average lag in milliseconds
-    #
-    # @param out [IO] output destination (default: $stderr)
-    # @return [void]
-    # @api public
     def self.dump(out: $stderr)
       snap = Phronomy::Metrics.snapshot
 
       out.puts "[Phronomy::Diagnostics] Runtime state dump"
-      out.puts "  BlockingAdapterPool:"
-      out.puts "    pool_size       : #{snap[:blocking_pool_size]}"
-      out.puts "    active_count    : #{snap[:blocking_pool_active]}"
-      out.puts "    queue_depth     : #{snap[:blocking_pool_queue_length]}"
-      out.puts "    abandoned_total : #{snap[:blocking_pool_abandoned_total]}"
+      out.puts "  OffloadPool:"
+      out.puts "    pool_size        : #{snap[:offload_pool_size]}"
+      out.puts "    active_count     : #{snap[:offload_pool_active]}"
+      out.puts "    queue_depth      : #{snap[:offload_pool_queue_length]}"
+      out.puts "    abandoned_active : #{snap[:offload_pool_abandoned_active]}"
+      out.puts "    abandoned_total  : #{snap[:offload_pool_abandoned_total]}"
       out.puts "  EventLoop:"
-      out.puts "    last_lag_ms     : #{snap[:event_loop_lag_last_ms]}"
-      out.puts "    max_lag_ms      : #{snap[:event_loop_lag_max_ms]}"
-      out.puts "    average_lag_ms  : #{snap[:event_loop_lag_average_ms]}"
+      out.puts "    last_lag_ms      : #{snap[:event_loop_lag_last_ms]}"
+      out.puts "    max_lag_ms       : #{snap[:event_loop_lag_max_ms]}"
+      out.puts "    average_lag_ms   : #{snap[:event_loop_lag_average_ms]}"
     end
 
-    # Returns the diagnostics state as a plain Hash (useful for JSON export).
-    #
-    # @return [Hash]
-    # @api public
     def self.snapshot
       Phronomy::Metrics.snapshot
     end
 
-    # Raises an error if +invoke+ (blocking) is called from inside an EventLoop
-    # action, preventing accidental scheduler stalls.
-    #
-    # Called by Agent::Base#invoke and Workflow#invoke before executing.
-    #
-    # @raise [Phronomy::SchedulerReentrancyError] when called from EventLoop thread
-    # @return [void]
-    # @api private
     def self.assert_not_in_event_loop!
       return unless Phronomy::Runtime.in_event_loop_context?
 
-      raise Phronomy::SchedulerReentrancyError,
-        "Blocking invoke called from inside an EventLoop action. " \
-        "Use invoke_async instead."
+      raise Phronomy::EventLoopReentrancyError,
+        "Blocking invoke called from inside an EventLoop action. Use invoke_async instead."
     end
   end
 end