smith-agents 0.11.0 → 0.12.1

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,7 +496,7 @@ 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} (#{e.class})")
       end

data/lib/smith/workflow/evaluator_optimizer.rb

@@ -33,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
 
@@ -41,10 +43,13 @@ 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)
-        rejection = before_eval_rejection(state)
-        evaluation = rejection || 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)
@@ -219,8 +224,9 @@ module Smith
         prior.push(role: :user, content:)
       end
 
-      # A structured candidate (an output_schema agent's Hash or Array) gets
-      # the JSON serialisation the provider boundary applies; text stays as is.
+      # 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

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
@@ -37,25 +39,47 @@ module Smith
         # The optimizer's verdict carrier resets for the same reason.
         @pending_agent_execution = nil
         @pending_evaluations = nil
-        output = with_scoped_artifacts { run_with_retry_policy(transition) }
-        StepCompletion.instance_method(:complete_step).bind_call(self, transition, output)
+        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
@@ -82,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)
@@ -117,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

data/lib/smith/workflow/failure_reconstructor.rb

@@ -19,17 +19,32 @@ module Smith
         "persisted_failure_invalid" => ->(record) { Smith::PersistedFailureInvalid.new(record[:error_message]) },
         "deadline_exceeded" => ->(record) { Smith::DeadlineExceeded.new(record[:error_message]) },
         "provider_permanent_failure" => ->(record) { provider_permanent_failure(record) },
-        "budget_exceeded" => ->(record) { Smith::BudgetExceeded.new(record[:error_message]) },
+        "budget_exceeded" => ->(record) { budget_exceeded(record) },
         "guardrail_failed" => ->(record) { Smith::GuardrailFailed.new(record[:error_message]) },
         "agent_error" => ->(record) { Smith::AgentError.new(record[:error_message]) },
         "workflow_error" => ->(record) { Smith::WorkflowError.new(record[:error_message]) },
+        "output_failure" => lambda { |record|
+          Smith::OutputFailure.from_details(record.fetch(:error_details), message: record[:error_message])
+        },
+        "child_runs_failed" => lambda { |record|
+          Smith::ChildRunsFailed.from_details(record.fetch(:error_details), message: record[:error_message])
+        },
+        "wait_timed_out" => lambda { |record|
+          Smith::WaitTimedOut.from_details(record.fetch(:error_details), message: record[:error_message])
+        },
         "other" => ->(record) { RuntimeError.new(record[:error_message]) }
       }.freeze
       SPECIAL_CLASS_BUILDERS = {
         "Smith::Workflow::Composite::BranchFailure" => lambda { |record|
           Smith::Workflow::Composite::BranchFailure.from_details(record[:error_details])
         },
-        "Smith::BlankAgentOutputError" => ->(record) { blank_agent_output_failure(record) }
+        "Smith::BlankAgentOutputError" => ->(record) { blank_agent_output_failure(record) },
+        "Smith::PersistedStateTooLarge" => lambda { |record|
+          Smith::PersistedStateTooLarge.from_details(record.fetch(:error_details), message: record[:error_message])
+        },
+        **Smith::OutputFailure.restorers.transform_values do |restore|
+          ->(record) { restore.call(record.fetch(:error_details), record[:error_message]) }
+        end
       }.freeze
       private_constant :FAMILY_BUILDERS, :SPECIAL_CLASS_BUILDERS
 
@@ -77,6 +92,13 @@ module Smith
         Smith::ToolFailureNotificationFailed.from_details(record.fetch(:error_details))
       end
 
+      # A host ledger's refusal stays one, so a host can tell waiting for
+      # budget from a run whose own budget ran out.
+      def self.budget_exceeded(record)
+        error_class = record[:error_class] == "Smith::BudgetUnavailable" ? Smith::BudgetUnavailable : Smith::BudgetExceeded
+        error_class.new(record[:error_message])
+      end
+
       def self.provider_permanent_failure(record)
         Smith::ProviderPermanentFailure.from_details(record.fetch(:error_details), message: record[:error_message])
       end
@@ -88,8 +110,9 @@ module Smith
         Smith::BlankAgentOutputError.from_details(details)
       end
 
-      private_class_method :deterministic_step_failure, :tool_guardrail_failure, :tool_failure_notification_failure,
-                           :provider_permanent_failure, :blank_agent_output_failure
+      private_class_method :budget_exceeded, :deterministic_step_failure, :tool_guardrail_failure,
+                           :tool_failure_notification_failure, :provider_permanent_failure,
+                           :blank_agent_output_failure
     end
   end
 end

data/lib/smith/workflow/failure_record.rb

@@ -4,6 +4,8 @@ require "dry-initializer"
 
 require_relative "../diagnostic_text"
 require_relative "../errors"
+require_relative "../output_failure"
+require_relative "../child_runs_failed"
 require_relative "failure_detail_snapshot"
 require_relative "failure_record_text"
 
@@ -23,7 +25,10 @@ module Smith
         [Smith::ProviderPermanentFailure, "provider_permanent_failure"],
         [Smith::BudgetExceeded, "budget_exceeded"],
         [Smith::GuardrailFailed, "guardrail_failed"],
+        [Smith::OutputFailure, "output_failure"],
         [Smith::AgentError, "agent_error"],
+        [Smith::WaitTimedOut, "wait_timed_out"],
+        [Smith::ChildRunsFailed, "child_runs_failed"],
         [Smith::WorkflowError, "workflow_error"]
       ].freeze
       BOOLEAN_VALUES = [true, false].freeze
@@ -126,7 +131,7 @@ module Smith
         FailureDetailSnapshot.new(error.details).call
       rescue StandardError => e
         FailureDetailSnapshot.new(
-          smith_failure_details_omitted: DiagnosticText.capture(e.message, max_bytes: 1_024)
+          smith_failure_details_omitted: DiagnosticText.capture(error_message(e), max_bytes: 1_024)
         ).call
       end
     end

data/lib/smith/workflow/failure_record_validator.rb

@@ -3,6 +3,8 @@
 require "dry-initializer"
 
 require_relative "../errors"
+require_relative "../output_failure"
+require_relative "../child_runs_failed"
 require_relative "composite/branch_failure"
 
 module Smith
@@ -19,11 +21,14 @@ module Smith
         "Smith::PersistedFailureInvalid" => "persisted_failure_invalid",
         "Smith::AgentError" => "agent_error",
         "Smith::BlankAgentOutputError" => "agent_error",
+        **Smith::OutputFailure.restorers.transform_values { "output_failure" },
         "Smith::DeadlineExceeded" => "deadline_exceeded",
         "Smith::ProviderPermanentFailure" => "provider_permanent_failure",
-        "Smith::BudgetExceeded" => "budget_exceeded",
+        "Smith::BudgetExceeded" => "budget_exceeded", "Smith::BudgetUnavailable" => "budget_exceeded",
         "Smith::GuardrailFailed" => "guardrail_failed",
-        "Smith::WorkflowError" => "workflow_error",
+        "Smith::WaitTimedOut" => "wait_timed_out",
+        "Smith::ChildRunsFailed" => "child_runs_failed",
+        "Smith::WorkflowError" => "workflow_error", "Smith::PersistedStateTooLarge" => "workflow_error",
         "Smith::UnresolvedTransitionError" => "workflow_error",
         "Smith::Workflow::Composite::BranchFailure" => "workflow_error"
       }.freeze
@@ -38,7 +43,7 @@ module Smith
         deterministic_step_failure tool_guardrail_failed tool_failure_notification_failed tool_capture_failed
         tool_outcome_uncertain tool_execution_not_admitted bounded_completion_error persisted_failure_invalid
         deadline_exceeded provider_permanent_failure budget_exceeded guardrail_failed agent_error workflow_error
-        other
+        wait_timed_out output_failure child_runs_failed other
       ].freeze
       RETRY_FORBIDDEN_FAMILIES = %w[
         tool_capture_failed tool_failure_notification_failed tool_outcome_uncertain tool_execution_not_admitted
@@ -53,9 +58,11 @@ module Smith
           Smith::Workflow::Composite::BranchFailure.from_details(details)
         },
         "Smith::ProviderPermanentFailure" => ->(details) { Smith::ProviderPermanentFailure.from_details(details) },
+        **[WaitTimedOut, ChildRunsFailed, PersistedStateTooLarge].to_h { [_1.name, _1.method(:from_details)] },
         "Smith::BlankAgentOutputError" => lambda { |details|
           Smith::BlankAgentOutputError.from_details(details) unless details.nil?
-        }
+        },
+        **Smith::OutputFailure.restorers
       }.freeze
       BOOLEAN_VALUES = [true, false].freeze
       private_constant :KNOWN_ERROR_FAMILIES, :LEGACY_ERROR_FAMILIES, :KNOWN_FAMILIES, :RETRY_FORBIDDEN_FAMILIES,

data/lib/smith/workflow/fanout_execution.rb

@@ -20,13 +20,10 @@ module Smith
         branch_agent_classes = fanout_agent_classes(transition, branches)
         run_workflow_input_guardrails
         run_fanout_agent_input_guardrails(branch_agent_classes)
-        prepared_input = build_session&.prepare!
-        output = execute_fanout_step(
-          transition,
-          branches: branches,
-          branch_agent_classes: branch_agent_classes,
-          prepared_input: prepared_input
-        )
+        prepared_input = step_prepared_input(transition)
+        return send_fanout_batch(transition, branches, branch_agent_classes, prepared_input) if batch_send?(transition)
+
+        output = execute_fanout_step(transition, branches:, branch_agent_classes:, prepared_input:)
         run_workflow_output_guardrails(output)
         output
       end
@@ -68,7 +65,7 @@ module Smith
       def guarded_fanout_branch_call(agent_class, env, signal)
         check_cancellation!(signal)
         check_deadline!
-        result = agent_class.model_configured? ? invoke_agent(agent_class, env.prepared_input) : nil
+        result = invoke_agent(agent_class, env.prepared_input)
         output = result.is_a?(AgentResult) ? result.content : result
         validate_data_volume!(output, agent_class)
         run_agent_output_guardrails(output, agent_class)