smith-agents 0.10.0 → 0.12.0

data/lib/smith/workflow/durability.rb

@@ -104,9 +104,26 @@ module Smith
             return false if fallback_age.nil? || fallback_age < threshold_seconds
           end
 
+          stuck_payload?(payload, now, threshold_seconds)
+        end
+
+        # A waiting run is not stuck until its deadline has passed by the
+        # threshold without the host expiring the wait; a run that waits is
+        # never terminal.
+        def stuck_payload?(payload, now, threshold_seconds)
+          wait_deadline = payload_wait_deadline(payload)
+          return (now - wait_deadline) > threshold_seconds if wait_deadline
+
           !terminal_in_payload?(payload)
         end
 
+        def payload_wait_deadline(payload)
+          deadline = JSON.parse(payload).dig("awaiting", "deadline_at")
+          deadline && Time.iso8601(deadline)
+        rescue JSON::ParserError, ArgumentError, TypeError
+          nil
+        end
+
         def heartbeat_age(persistence_key:, adapter: Smith.persistence_adapter)
           raise WorkflowError, "persistence_adapter is not configured" if adapter.nil?
 
@@ -121,6 +138,20 @@ module Smith
           age_from_payload_updated_at(payload, Time.now.utc)
         end
 
+        # Delivers `event` to the run stored under `key` (see
+        # Workflow#resume!) and stores the result with the version check.
+        # Returns `:resumed`, or `:stale` when no run is stored or it does not
+        # await this event and token.
+        def resume!(key, event:, token:, payload:, adapter: Smith.persistence_adapter)
+          stored_wait_call(key, adapter:, done: :resumed) { |workflow| workflow.resume!(event:, token:, payload:) }
+        end
+
+        # Ends the stored run's wait if its deadline has passed at `now` (see
+        # Workflow#expire_wait!). The host's scheduler decides when to call it.
+        def expire_wait!(key, token:, now: Time.now.utc, adapter: Smith.persistence_adapter)
+          stored_wait_call(key, adapter:, done: :expired) { |workflow| workflow.expire_wait!(token:, now:) }
+        end
+
         def run_persisted!(key: nil, context: {}, adapter: Smith.persistence_adapter, clear: :done, on_step: nil, **kwargs)
           clear_policy = normalize_clear_policy(clear)
           resolved_key = resolved_persistence_key(key:, context:)
@@ -133,6 +164,53 @@ module Smith
 
         private
 
+        # Exactly one completion of a wait must win, so the store must check
+        # versions. A run caught mid-step (strict mode) can still take an
+        # early delivery for the await it is entering; anything else about it
+        # is refused as an unfinished step.
+        def stored_wait_call(key, adapter:, done:, &)
+          resolved_key = explicit_persistence_key!(key)
+          store = persistence_adapter!(adapter)
+          unless Smith::PersistenceAdapters.supports?(store, :store_versioned)
+            raise WorkflowError, "resume! and expire_wait! need a persistence adapter with store_versioned"
+          end
+
+          payload = fetch_persisted_payload(resolved_key, adapter: store)
+          return :missing unless payload
+
+          stored_wait_result(JSON.parse(payload), resolved_key, store, done, &)
+        end
+
+        def stored_wait_result(state, key, store, done)
+          workflow, in_progress = restore_for_wait(state)
+          workflow.instance_variable_set(:@persistence_key, key)
+          mark_batch_completion!(workflow, key, store, in_progress)
+          result = yield(workflow)
+          raise in_progress if in_progress && result != :resumed && result != :failed
+
+          workflow.clear_step_in_progress!
+          workflow.persist!(key, adapter: store) if [done, :failed].include?(result)
+          result
+        end
+
+        # A batch completion makes provider calls (a follow-up, a retry over
+        # the wire, a new batch), so in strict mode it runs as a marked step:
+        # stored as under way first, and a run caught in one is unfinished.
+        def mark_batch_completion!(workflow, key, store, in_progress)
+          return unless workflow.send(:batch_waiting?)
+          raise in_progress if in_progress
+          return unless idempotency_mode == :strict
+
+          workflow.mark_step_in_progress!
+          workflow.persist!(key, adapter: store)
+        end
+
+        def restore_for_wait(state)
+          [from_state(state), nil]
+        rescue Smith::StepInProgressOnRestore => e
+          [allocate.tap { |workflow| workflow.send(:restore_state, state, allow_step_in_progress: true) }, e]
+        end
+
         def fetch_persisted_payload(key, adapter:)
           persistence_adapter!(adapter).fetch(key)
         end
@@ -158,25 +236,19 @@ module Smith
           parsed = JSON.parse(payload)
           state_name = parsed["state"] || parsed[:state]
           class_name = parsed["class"] || parsed[:class]
-          next_transition = parsed["next_transition_name"] || parsed[:next_transition_name]
-
           return false unless state_name && class_name
 
-          klass = Object.const_get(class_name)
-          state = state_name_for_payload(klass, state_name)
-          !klass.transition_from?(state) && next_transition.nil?
+          next_transition = parsed["next_transition_name"] || parsed[:next_transition_name]
+          terminal_payload_state?(Object.const_get(class_name), state_name, next_transition)
         rescue JSON::ParserError, NameError, NoMethodError
           false
         end
 
-        def state_name_for_payload(klass, state_name)
-          states = klass.instance_variable_get(:@states) || []
-          return state_name if states.include?(state_name)
-
-          symbolized = state_name.to_sym if state_name.respond_to?(:to_sym)
-          return symbolized if states.include?(symbolized)
-
-          state_name
+        # A state the class no longer knows can never advance or restore, so
+        # it is not terminal: an old one reports as stuck.
+        def terminal_payload_state?(klass, state_name, next_transition)
+          state = klass.resolve_state_name(state_name)
+          !state.nil? && !klass.transition_from?(state) && next_transition.nil?
         end
 
         def persistence_adapter!(adapter)
@@ -192,7 +264,7 @@ module Smith
           raise WorkflowError, "persistence key is required unless workflow defines persistence_key" unless builder
 
           derived = if builder.arity == 1
-            builder.call(context)
+            builder.call(ContextKeys.normalize_context(context))
           else
             builder.call
           end
@@ -241,17 +313,19 @@ module Smith
       end
 
       def run_persisted!(key = nil, adapter: Smith.persistence_adapter, on_step: nil)
-        return build_run_result([]) if terminal?
+        return build_run_result([]) if nothing_to_advance?
 
         resolved_key = resolve_persistence_key!(key)
         steps = []
+        mark_active_step_start!(true)
         persist!(resolved_key, adapter:)
 
-        until terminal?
+        until nothing_to_advance?
           ensure_transition_budget!
 
           if strict_idempotency?
-            mark_step_in_progress!
+            mark_step_in_progress! unless replay_safe_pending_step?
+            mark_active_step_start!(true)
             persist!(resolved_key, adapter:)
           end
 
@@ -264,6 +338,7 @@ module Smith
           steps << step if step
 
           clear_step_in_progress!
+          mark_active_step_start!(!nothing_to_advance?)
           persist!(resolved_key, adapter:)
           invoke_on_step_callback(step, on_step) if step
         end
@@ -272,17 +347,15 @@ module Smith
       end
 
       def advance_persisted!(key = nil, adapter: Smith.persistence_adapter, on_step: nil)
-        return if terminal?
+        return if nothing_to_advance?
 
         resolved_key = resolve_persistence_key!(key)
         ensure_transition_budget!
-        mark_step_in_progress! if strict_idempotency?
+        mark_step_in_progress! if strict_idempotency? && !replay_safe_pending_step?
+        mark_active_step_start!(true)
         persist!(resolved_key, adapter:)
         step = advance!
-        clear_step_in_progress!
-        persist!(resolved_key, adapter:) if step
-        invoke_on_step_callback(step, on_step) if step
-        step
+        finish_persisted_advance!(step, resolved_key, adapter, on_step)
       rescue StandardError
         clear_pre_step_marker!(resolved_key, adapter:) if defined?(resolved_key) && resolved_key
         raise
@@ -296,12 +369,7 @@ module Smith
         payload = JSON.generate(to_state.merge(persistence_version: next_version))
         payload = yield(payload, next_version) if block_given?
 
-        dispatch_store!(store, resolved_key, payload, previous_version: previous_version)
-
-        # Increment ONLY after successful store. On PersistenceVersionConflict
-        # (raised by store_versioned), @persistence_version stays at the
-        # previous value so callers can rescue + restore + retry cleanly.
-        @persistence_version = next_version
+        store_payload!(store, resolved_key, payload, previous_version:)
         self
       end
 
@@ -311,6 +379,12 @@ module Smith
         self
       end
 
+      # A map, call or spawn launches through a launcher that is idempotent
+      # by contract, so strict mode lets its step run again after a crash.
+      def replay_safe_pending_step?
+        self.class.find_transition(pending_transition_name)&.child_runs? || false
+      end
+
       def mark_step_in_progress!
         @step_in_progress = true
       end
@@ -321,6 +395,33 @@ module Smith
 
       private
 
+      # Increment ONLY after successful store. On PersistenceVersionConflict
+      # (raised by store_versioned), @persistence_version stays at the
+      # previous value so callers can rescue + restore + retry cleanly. A
+      # streamed step's output reaches its sink once stored (StepStream); a
+      # store that fails tells the sink the step failed.
+      def store_payload!(store, key, payload, previous_version:)
+        begin
+          check_state_size!(key, payload)
+          dispatch_store!(store, key, payload, previous_version:)
+        rescue StandardError => e
+          StepStream.instance_method(:discard_streamed_output).bind_call(self, e.class)
+          raise
+        end
+        @persistence_version = previous_version + 1
+        StepStream.instance_method(:deliver_streamed_output).bind_call(self)
+      end
+
+      # The step, or the wait it entered, is stored, and the mark of a step
+      # under way is cleared.
+      def finish_persisted_advance!(step, key, adapter, on_step)
+        clear_step_in_progress!
+        mark_active_step_start!(false)
+        persist!(key, adapter:)
+        invoke_on_step_callback(step, on_step) if step
+        step
+      end
+
       def strict_idempotency?
         self.class.idempotency_mode == :strict
       end
@@ -330,6 +431,7 @@ module Smith
         return if step_work_started?
 
         clear_step_in_progress!
+        mark_active_step_start!(false)
         persist!(key, adapter:)
       end
 
@@ -350,6 +452,13 @@ module Smith
         store.record_heartbeat(key, **kwargs) if Smith::PersistenceAdapters.supports?(store, :record_heartbeat)
       end
 
+      # A state past persistence_max_bytes is refused before anything is
+      # written, and before a split-step boundary counts a write as begun.
+      def check_state_size!(key, payload)
+        limit = Smith.config.persistence_max_bytes
+        raise PersistedStateTooLarge.new(key:, bytes: payload.bytesize, limit:) if limit && payload.bytesize > limit
+      end
+
       # Resolves the effective TTL once per persist, with the class-level
       # DSL override taking precedence over Smith.config.persistence_ttl.
       # Returns nil when neither is set, which collapses ttl_kwarg to an
@@ -387,9 +496,9 @@ module Smith
       end
 
       def invoke_on_step_callback(step, callback)
-        callback&.call(step)
+        IdempotencyKey.__send__(:without) { callback&.call(step) }
       rescue StandardError => e
-        Smith.config.logger&.error("Smith::Workflow on_step callback error: #{e.message}")
+        Smith.config.logger&.error("Smith::Workflow on_step callback error: #{e.message} (#{e.class})")
       end
     end
   end

data/lib/smith/workflow/evaluator_optimizer.rb

@@ -3,6 +3,7 @@
 require "json"
 
 require_relative "agent_result"
+require_relative "execution_result_snapshot"
 require_relative "optimization_state"
 
 module Smith
@@ -24,6 +25,7 @@ module Smith
           transition_name: transition.name,
           role: :evaluator
         )
+        pend_evaluations
         run_optimization_loop(state)
       end
 
@@ -31,7 +33,9 @@ module Smith
         state.config[:max_rounds].times do |round|
           # The overlay scopes every trace and usage fact from this round's
           # generator and evaluator calls to the round that produced them.
-          result = Attribution.with(round: round) { run_optimization_round(state, round) }
+          result = Attribution.with(round: round) do
+            IdempotencyKey.__send__(:within, :round, round) { run_optimization_round(state, round) }
+          end
           return result if result
         end
 
@@ -39,12 +43,16 @@ module Smith
                     "optimization exhausted #{state.config[:max_rounds]} rounds without acceptance")
       end
 
+      # Each role is a position of its own in the round, so the generator,
+      # the before_eval callback and the evaluator never share a key.
       def run_optimization_round(state, round)
-        generate_candidate!(state, round)
-        invoke_before_eval(state)
-        evaluation = normalize_evaluation(evaluate_candidate(state))
+        IdempotencyKey.__send__(:within, :generator) { generate_candidate!(state, round) }
+        rejection = IdempotencyKey.__send__(:within, :before_eval) { before_eval_rejection(state) }
+        evaluation = rejection ||
+                     normalize_evaluation(IdempotencyKey.__send__(:within, :evaluator) { evaluate_candidate(state) })
         validate_evaluation_structure!(evaluation)
         validate_evaluation_fields!(evaluation, state.config)
+        record_evaluation(state, evaluation, round, rejection ? :before_eval : :evaluator)
 
         return state.candidate if evaluation[:accept]
 
@@ -61,6 +69,88 @@ module Smith
         nil
       end
 
+      # Each valid round's evaluation, in round order: the round, whether the
+      # evaluator or a before_eval rejection gave it, and the verdict as
+      # normalized, copied and frozen so neither the loop nor a host holding a
+      # record can change it. Recorded before any exit, so the verdict that
+      # ends the loop (accepted, converged, or under the threshold) is kept.
+      # The loop's state carries a frozen copy, so a callable reads the
+      # verdicts so far and cannot rewrite the step's.
+      def record_evaluation(state, evaluation, round, source)
+        records = @pending_evaluations.values.last
+        record = { round: round, source: source, verdict: frozen_verdict(evaluation) }.freeze
+        within_step_record_limits!(@pending_evaluations.values.flatten(1) << record)
+        records << record
+        state.evaluations = records.dup.freeze
+      end
+
+      # The verdicts ride on the step's record, which a split step snapshots
+      # under ExecutionResultSnapshot's limits. A round whose verdict would
+      # take the step's verdicts past them fails here, the same way in every
+      # run mode, and the verdicts already recorded still fit a failed step's
+      # record.
+      def within_step_record_limits!(records)
+        ExecutionResultSnapshot.new({ evaluations: records }).call
+      rescue WorkflowError => e
+        raise WorkflowError, "evaluations exceed a step record's limits: #{e.message}"
+      end
+
+      # A verdict holds JSON values only, as a provider's structured output
+      # does: anything else (an object a before_eval returned, a key that is
+      # not a String or Symbol, a non-finite Float) fails the round here, the
+      # same way in every run mode, rather than when a split step snapshots it.
+      def frozen_verdict(value)
+        case value
+        when Hash then value.to_h { |key, nested| [verdict_key(key), frozen_verdict(nested)] }.freeze
+        when Array then value.map { |nested| frozen_verdict(nested) }.freeze
+        when String then StringSnapshot.copy(value, freeze: true)
+        else verdict_scalar(value)
+        end
+      end
+
+      def verdict_scalar(value)
+        case value
+        when Float then finite_verdict_number(value)
+        when Symbol, Integer, true, false, nil then value
+        else raise WorkflowError, "evaluation must hold JSON values; got #{value.class}"
+        end
+      end
+
+      def verdict_key(key)
+        return key if key.is_a?(Symbol)
+        return StringSnapshot.copy(key, freeze: true) if key.is_a?(String)
+
+        raise WorkflowError, "evaluation keys must be Strings or Symbols; got #{key.class}"
+      end
+
+      def finite_verdict_number(value)
+        return value if value.finite?
+
+        raise WorkflowError, "evaluation must hold finite numbers; got #{value}"
+      end
+
+      # An optimize step's record carries every verdict its loops recorded
+      # under :evaluations, whether the step completed or failed, each naming
+      # the attempt that gave it (`@step_attempt`, the retry policy's): a step
+      # `retry_on` runs again starts its loop afresh, rounds counting from 0
+      # again, and an earlier attempt's verdicts were given and paid for all
+      # the same. The key is there whenever a loop ran; a step that failed
+      # before its loop (an agent not registered, a guardrail) and any other
+      # step have none. The carrier is transient: the loop's list keyed by its
+      # attempt, cleared once the step's record is committed or its failure
+      # captured, and at every step's start.
+      def pend_evaluations
+        (@pending_evaluations ||= {})[@step_attempt || 1] = []
+      end
+
+      def fold_pending_evaluations(step)
+        return unless @pending_evaluations
+
+        step[:evaluations] = @pending_evaluations.flat_map do |attempt, records|
+          records.map { |record| { attempt: attempt, **record }.freeze }
+        end.freeze
+      end
+
       # :raise => WorkflowError(message); :return_last => state.candidate;
       # callable => mode.call(state). Default :raise preserves legacy
       # behavior for hosts that don't opt in to graceful exits.
@@ -127,21 +217,35 @@ module Smith
       # evaluator sees the same seed_messages + inject_state context.
       # Default nil keeps the legacy candidate-only payload.
       def build_evaluator_input(state)
-        return [{ role: :user, content: state.candidate.to_s }] unless state.config[:evaluator_context] == :inject_state
+        content = candidate_content(state.candidate)
+        return [{ role: :user, content: }] unless state.config[:evaluator_context] == :inject_state
 
         prior = Array(state.prepared_input).dup
-        prior.push(role: :user, content: state.candidate.to_s)
+        prior.push(role: :user, content:)
+      end
+
+      # A structured candidate (an output_schema agent's Hash, or an Array a
+      # schema-less generator returned) gets the JSON serialisation the
+      # provider boundary applies; text stays as is.
+      def candidate_content(candidate)
+        candidate.is_a?(Hash) || candidate.is_a?(Array) ? json_message_content(candidate) : candidate.to_s
       end
 
       # Runs after candidate generation, before evaluator invocation.
-      # Receives (state, @context); @context is mutable. Return value
-      # is discarded. Raised exceptions bubble through the standard
-      # step failure path.
-      def invoke_before_eval(state)
+      # Receives (state, @context); @context is mutable. A returned Hash
+      # whose accept (Symbol or String key) is false is the round's
+      # evaluation, validated like evaluator output, and the evaluator is
+      # not called; any other return value is discarded. Raised exceptions
+      # bubble through the standard step failure path.
+      def before_eval_rejection(state)
         callback = state.config[:before_eval]
         return unless callback
 
-        callback.call(state, @context)
+        verdict = callback.call(state, @context)
+        return unless verdict.is_a?(Hash)
+
+        evaluation = normalize_evaluation(verdict)
+        evaluation if evaluation.key?(:accept) && evaluation[:accept].equal?(false)
       end
 
       def invoke_with_evaluator_schema(evaluator_class, schema, input)
@@ -195,7 +299,7 @@ module Smith
         return prepared_input if round.zero?
 
         (prepared_input&.dup || []).push(
-          { role: :assistant, content: prior_candidate.to_s },
+          { role: :assistant, content: candidate_content(prior_candidate) },
           {
             role: :user,
             content: "[smith:refinement-round] #{round + 1}\n[smith:evaluator-feedback]\n#{feedback}"

data/lib/smith/workflow/event_integration.rb

@@ -11,6 +11,11 @@ module Smith
           data: { transition: transition.name, from: transition.from, to: transition.to }
         )
 
+        # Handlers are not a step's own work, so they get no idempotency key.
+        IdempotencyKey.__send__(:without) { emit_step_completed_event(transition) }
+      end
+
+      def emit_step_completed_event(transition)
         Smith::Events.emit(
           Events::StepCompleted.new(
             transition: transition.name.to_sym,
@@ -54,6 +59,10 @@ module Smith
       end
 
       def emit_step_failed_event(failure)
+        IdempotencyKey.__send__(:without) { emit_step_failed_bus_event(failure) }
+      end
+
+      def emit_step_failed_bus_event(failure)
         Smith::Events.emit(
           Events::StepFailed.new(
             transition: DiagnosticText.capture(failure[:transition].to_s, max_bytes: 256).to_sym,

data/lib/smith/workflow/execution.rb

@@ -6,6 +6,7 @@ require_relative "guarded_step_execution"
 require_relative "prepared_branch_execution"
 require_relative "step_completion"
 require_relative "step_context"
+require_relative "step_stream"
 
 module Smith
   class Workflow
@@ -15,6 +16,7 @@ module Smith
       include PreparedBranchExecution
       include StepCompletion
       include StepContext
+      include StepStream
       include Agent::Lifecycle
       include NestedExecution
       include EvaluatorOptimizer
@@ -34,26 +36,50 @@ module Smith
         # Reset the per-step agent-attribution carrier so only a serial agent
         # step that actually runs (below) leaves model/provider for complete_step;
         # a deterministic step never sets it and must not inherit a stale value.
+        # The optimizer's verdict carrier resets for the same reason.
         @pending_agent_execution = nil
-        output = with_scoped_artifacts { run_with_retry_policy(transition) }
-        StepCompletion.instance_method(:complete_step).bind_call(self, transition, output)
+        @pending_evaluations = nil
+        writable_output_key!(transition) if transition.output_to
+        with_step_stream(transition) do
+          output = with_scoped_artifacts { run_with_retry_policy(transition) }
+          output = queue_batch(transition, output) if output.is_a?(BatchExecution::Captured)
+          next output if wait_pending?(output)
+
+          StepCompletion.instance_method(:complete_step).bind_call(self, transition, output)
+        end
+      ensure
+        release_batch_holds
       end
 
+      # Restored with the step's thread context (ThreadContextSnapshot): a
+      # step's depth counts the runs whose steps it runs inside.
       def setup_step_context
+        Thread.current[:smith_step_depth] = (Thread.current[:smith_step_depth] || 0) + 1
         Tool.current_deadline = wall_clock_deadline
         Tool.current_ledger = @ledger
         Tool.current_tool_result_collector = tool_result_collector
       end
 
+      # An await, delay, map or call waits; a spawn launches and continues.
+      def execute_waiting_step(transition)
+        transition.spawns? ? execute_spawn_step(transition) : execute_await_step(transition)
+      end
+
       def run_standard_guarded_step(transition)
+        return execute_waiting_step(transition) if transition.awaits? || transition.spawns?
         return dispatch_step(transition) if transition.deterministic?
         return run_guarded_fanout_step(transition) if transition.fanout?
 
         agent_class = resolve_agent_class(transition)
         run_input_guardrails(agent_class)
         apply_tool_guardrails(agent_class)
-        prepared_input = build_session&.prepare!
+        prepared_input = step_prepared_input(transition)
+        return send_agent_batch(transition, agent_class, prepared_input) if batch_send?(transition)
+
+        guarded_agent_output(transition, agent_class, prepared_input)
+      end
 
+      def guarded_agent_output(transition, agent_class, prepared_input)
         output = with_agent_context(agent_class) do
           dispatch_step(transition, prepared_input: prepared_input)
         end
@@ -80,13 +106,9 @@ module Smith
         @last_prepared_input = prepared_input
         return nil unless transition.agent_name
 
-        agent_class = resolve_agent_class(transition)
-        # Accepts either static `model "id"` (chat_kwargs[:model]) OR
-        # block-form `model { |ctx| ... }` (model_block). The block-form
-        # path resolves the actual id in build_model_chain at attempt time.
-        return nil unless agent_class.model_configured?
-
-        invoke_agent(agent_class, prepared_input)
+        # An agent with no model and no fallback models fails in
+        # complete_with_provider rather than skipping the step.
+        invoke_agent(resolve_agent_class(transition), prepared_input)
       end
 
       def execute_serial_step(transition, prepared_input: nil)
@@ -115,19 +137,6 @@ module Smith
         agent_class = resolve_agent_class(transition)
         reserve_serial_budget(ledger, agent_budget: agent_class&.budget)
       end
-
-      def resolve_agent_class(transition)
-        parallel_binding = Thread.current[:smith_parallel_agent_binding]
-        parallel_agent_class = parallel_binding&.resolve(workflow: self, transition:)
-        return parallel_agent_class if parallel_agent_class
-
-        transition.agent_name && resolve_registered_agent!(
-          transition.agent_name,
-          workflow_class: self.class,
-          transition_name: transition.name,
-          role: :agent
-        )
-      end
     end
   end
 end

data/lib/smith/workflow/execution_binding_resolution.rb

@@ -11,6 +11,19 @@ module Smith
 
         Agent::Registry.fetch!(name, workflow_class:, transition_name:, role:)
       end
+
+      def resolve_agent_class(transition)
+        parallel_binding = Thread.current[:smith_parallel_agent_binding]
+        parallel_agent_class = parallel_binding&.resolve(workflow: self, transition:)
+        return parallel_agent_class if parallel_agent_class
+
+        transition.agent_name && resolve_registered_agent!(
+          transition.agent_name,
+          workflow_class: self.class,
+          transition_name: transition.name,
+          role: :agent
+        )
+      end
     end
   end
 end