smith-agents 0.7.0 → 0.8.0

data/lib/smith/agent/lifecycle.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "provider_completion"
+require_relative "usage_tracking"
+
 module Smith
   class Agent
     module Lifecycle
-      WORKFLOW_CONTINUATION_MESSAGE =
-        "Use the preceding assistant result as input and perform your assigned workflow step."
-      private_constant :WORKFLOW_CONTINUATION_MESSAGE
-
-      TRANSIENT_ERRORS = [
-        RubyLLM::ServerError, RubyLLM::ServiceUnavailableError,
-        RubyLLM::OverloadedError, RubyLLM::RateLimitError
-      ].freeze
+      include ProviderCompletion
+      include UsageTracking
 
       private
 
@@ -23,274 +20,8 @@ module Smith
 
       def invoke_agent(agent_class, prepared_input, output_schema: agent_class.output_schema)
         check_deadline!
-        response, model_used = complete_with_provider(agent_class, prepared_input, output_schema:)
-        snapshot_and_finalize(agent_class, response, model_used)
-      end
-
-      # Returns [response, model_used] as local data — no shared mutable
-      # state. Previously this method set `@last_attempt_model` on the
-      # workflow instance and `snapshot_and_finalize` read it back; under
-      # parallel fan-out, two branches sharing the workflow could race
-      # and attribute the wrong model to the wrong response. Local data
-      # eliminates the race entirely.
-      def complete_with_provider(agent_class, prepared_input, output_schema:)
-        models = build_model_chain(agent_class)
-
-        models.each_with_index do |model_id, index|
-          check_deadline! if index.positive?
-          response = attempt_model(agent_class, prepared_input, model_id, output_schema:)
-          return [response, model_id]
-        rescue Smith::Error
-          raise
-        rescue StandardError => e
-          account_failed_attempt(e, model_id, agent_class)
-          raise Smith::AgentError, e.message unless fallback_eligible?(e) && index < models.length - 1
-        end
-      end
-
-      def build_model_chain(agent_class)
-        primary = if agent_class.respond_to?(:model_block) && agent_class.model_block
-                    resolve_dynamic_model(agent_class)
-                  else
-                    agent_class.chat_kwargs[:model]
-                  end
-        fallbacks = agent_class.fallback_models || []
-        [primary, *fallbacks].compact
-      end
-
-      # Evaluates a block-form `model` declaration with the workflow's
-      # @context (Hash, defaults to {} when uninitialized). The block
-      # must return a non-empty string model id; any other value
-      # surfaces as Smith::AgentError so the workflow's failure handler
-      # treats it as a step failure rather than a silent miss.
-      def resolve_dynamic_model(agent_class)
-        result = agent_class.model_block.call(@context || {})
-        return result if result.is_a?(String) && !result.empty?
-
-        raise Smith::AgentError,
-              "model block for #{agent_class} must return a non-empty string; got #{result.inspect}"
-      end
-
-      def attempt_model(agent_class, prepared_input, model_id, output_schema:)
-        chat = agent_class.chat(model: model_id, **bridge_workflow_inputs(agent_class))
-        add_prepared_input(chat, prepared_input)
-        chat = chat.with_schema(output_schema) if output_schema
-        chat.complete
-      end
-
-      # Bridges declared agent `inputs` from the workflow's @context Hash
-      # to the agent invocation kwargs, so block-form RubyLLM DSLs (tools,
-      # instructions, params, headers, schema) can access workflow-context
-      # data via bare method calls on `self` inside the block (RubyLLM
-      # invokes these via `runtime.instance_exec(&block)`, exposing each
-      # declared input as a singleton method on the runtime object).
-      # Smith's own `model` block-form already receives @context directly
-      # via `block.call(@context)`; this bridge gives runtime_context the
-      # same surface for the RubyLLM-owned blocks.
-      #
-      # Bridges ONLY user-declared inputs — reserved names
-      # (Smith::Agent::RESERVED_INPUT_NAMES: model_id, provider,
-      # endpoint_mode) are auto-injected by Smith::Agent.chat from the
-      # resolved profile, NOT from @context. The slice prevents the bridge
-      # from accidentally passing through stale or wrong values that
-      # happen to live in @context under those keys.
-      #
-      # Contract: declared inputs are ALWAYS passed (with nil when absent
-      # from @context). The declaration is the contract — `inputs :form_kind`
-      # promises that `form_kind` will be a callable singleton method on
-      # the runtime regardless of whether @context happens to have a value.
-      # This eliminates `respond_to?` defensiveness in agent blocks and
-      # mirrors the silent-nil semantics agent authors get from `ctx[:k]`
-      # in the model block. Non-Hash @context short-circuits.
-      def bridge_workflow_inputs(agent_class)
-        return {} unless @context.is_a?(Hash)
-
-        declared = agent_class.inputs || []
-        user_declared = declared - Smith::Agent::RESERVED_INPUT_NAMES
-        user_declared.to_h do |name|
-          [name, @context[name]]
-        end
-      end
-
-      def add_prepared_input(chat, prepared_input)
-        return unless prepared_input
-
-        prepared_input = provider_safe_prepared_input(prepared_input)
-        system_messages, other_messages = prepared_input.partition do |message|
-          message_role(message) == :system
-        end
-
-        merge_system_messages!(chat, system_messages) if system_messages.any?
-        other_messages.each { |message| add_message(chat, message) }
-      end
-
-      def provider_safe_prepared_input(prepared_input)
-        messages = prepared_input.to_a
-        return messages unless workflow_handoff?(messages)
-
-        messages + [{ role: :user, content: WORKFLOW_CONTINUATION_MESSAGE }]
-      end
-
-      def workflow_handoff?(messages)
-        message = messages.reverse_each.find { |candidate| message_role(candidate) != :system }
-        return false unless message
-        return false unless message_role(message) == :assistant
-        return false unless defined?(@last_output) && !@last_output.nil?
-
-        message_content(message) == @last_output
-      end
-
-      def merge_system_messages!(chat, prepared_system_messages)
-        return prepared_system_messages.each { |message| add_message(chat, message) } unless chat.respond_to?(:messages)
-
-        existing_system_contents = chat.messages.filter_map do |message|
-          message.content if message_role(message) == :system
-        end
-        prepared_system_contents = prepared_system_messages.filter_map do |message|
-          message_content(message)
-        end
-
-        combined_contents = existing_system_contents + prepared_system_contents
-        return if combined_contents.empty?
-        unless combined_contents.all?(String)
-          return prepared_system_messages.each { |message| add_message(chat, message) }
-        end
-
-        if chat.respond_to?(:with_instructions)
-          chat.with_instructions(combined_contents.join("\n\n"))
-        else
-          prepared_system_messages.each { |message| add_message(chat, message) }
-        end
-      end
-
-      def add_message(chat, message)
-        attributes = if message.is_a?(Hash)
-                       message.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
-                     else
-                       message
-                     end
-        chat.add_message(attributes)
-      end
-
-      def message_role(message)
-        message_attribute(message, :role)&.to_sym
-      end
-
-      def message_content(message)
-        message_attribute(message, :content)
-      end
-
-      def message_attribute(message, name)
-        return message.public_send(name) if message.respond_to?(name)
-        return message[name] if message.respond_to?(:key?) && message.key?(name)
-
-        message[name.to_s]
-      end
-
-      def fallback_eligible?(error)
-        TRANSIENT_ERRORS.any? { |klass| error.is_a?(klass) } ||
-          error.is_a?(Faraday::TimeoutError) ||
-          error.is_a?(Faraday::ConnectionFailed)
-      end
-
-      # `agent_class` is now a parameter (was previously implicit via
-      # `@last_attempt_model`-only path). The caller (`complete_with_provider`)
-      # has the local already, so no shared mutable state is needed.
-      # Records the failed attempt's tokens via the unified `record_usage`
-      # helper, marking the entry as `:failed_attempt`.
-      def account_failed_attempt(error, model_id, agent_class)
-        return unless error.respond_to?(:input_tokens) && error.respond_to?(:output_tokens)
-
-        input = error.input_tokens
-        output = error.output_tokens
-        return unless input.is_a?(Integer) && output.is_a?(Integer)
-
-        cost = Smith::Pricing.compute_cost(model: model_id, input_tokens: input, output_tokens: output)
-        agent_result = Workflow::AgentResult.new(
-          content: nil, input_tokens: input, output_tokens: output, cost: cost, model_used: model_id
-        )
-        Thread.current[:smith_failed_agent_results] ||= []
-        Thread.current[:smith_failed_agent_results] << agent_result
-        record_usage(agent_class, agent_result, :failed_attempt, model_id)
-      end
-
-      def snapshot_and_finalize(agent_class, response, model_used)
-        agent_result = Workflow::AgentResult.from_response(response, response&.content, model_used: model_used)
-        Thread.current[:smith_last_agent_result] = agent_result
-        emit_token_usage(agent_result)
-        compute_agent_cost(agent_result)
-        record_usage(agent_class, agent_result, :completed_attempt, agent_result.model_used)
-
-        agent_result.content = run_after_completion(agent_class, agent_result.content, @context)
-        raise_blank_output!(agent_class, agent_result)
-        agent_result
-      end
-
-      def raise_blank_output!(agent_class, agent_result)
-        return unless blank_agent_output?(agent_result.content)
-
-        raise Smith::BlankAgentOutputError.new(
-          agent_name: agent_class.register_as,
-          model_used: agent_result.model_used
-        )
-      end
-
-      def blank_agent_output?(content)
-        return true if content.nil?
-        return content.strip.empty? if content.is_a?(String)
-
-        false
-      end
-
-      def emit_token_usage(agent_result)
-        return unless agent_result.usage_known?
-
-        Smith::Trace.record(
-          type: :token_usage,
-          data: { input_tokens: agent_result.input_tokens, output_tokens: agent_result.output_tokens }
-        )
-      end
-
-      def compute_agent_cost(agent_result)
-        return unless agent_result.usage_known?
-
-        model = agent_result.model_used
-        agent_result.cost = Smith::Pricing.compute_cost(
-          model: model, input_tokens: agent_result.input_tokens, output_tokens: agent_result.output_tokens
-        )
-      end
-
-      # Single critical section: all three of `@total_tokens`,
-      # `@total_cost`, and `@usage_entries` update under one mutex
-      # acquisition. Replaces the prior `accumulate_usage` which took
-      # the mutex twice (once for tokens, once for cost) — under
-      # parallel fan-out two branches could interleave between those
-      # blocks, leaving totals momentarily inconsistent. Adding the
-      # entry append in a third pass would have widened the window;
-      # one pass closes it entirely.
-      #
-      # `@usage_mutex` is eagerly initialized in `Workflow#initialize`
-      # AND `Workflow#restore_state` (since `from_state` allocates
-      # without `initialize`), so it's always present here.
-      def record_usage(agent_class, agent_result, attempt_kind, model_id)
-        return unless agent_result.usage_known?
-
-        entry = Workflow::UsageEntry.new(
-          usage_id: SecureRandom.uuid,
-          agent_name: agent_class.register_as,
-          model: model_id,
-          input_tokens: agent_result.input_tokens,
-          output_tokens: agent_result.output_tokens,
-          cost: agent_result.cost,
-          attempt_kind: attempt_kind,
-          recorded_at: Time.now.utc.iso8601
-        )
-
-        @usage_mutex.synchronize do
-          @total_tokens = (@total_tokens || 0) + agent_result.input_tokens + agent_result.output_tokens
-          @total_cost   = (@total_cost   || 0.0) + (agent_result.cost || 0.0)
-          @usage_entries << entry
-        end
+        completion, model_used = complete_with_provider(agent_class, prepared_input, output_schema:)
+        snapshot_and_finalize(agent_class, completion, model_used)
       end
     end
   end

data/lib/smith/agent/model_reference.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+require "ruby_llm"
+
+require_relative "../types"
+
+module Smith
+  class Agent < RubyLLM::Agent
+    class ModelReference < Dry::Struct
+      ModelId = Types::String.constructor do |value|
+        normalized = value.to_s.dup
+        raise ArgumentError, "model id must not be blank" if normalized.empty?
+
+        normalized.freeze
+      end
+      Provider = Types::Symbol.optional.constructor { |value| value&.to_sym }
+
+      private_constant :ModelId, :Provider
+
+      attribute :model_id, ModelId
+      attribute :provider, Provider
+
+      def initialize(attributes)
+        super
+        freeze
+      end
+
+      def self.coerce(value, provider: nil)
+        return value if value.is_a?(self)
+        return from_hash(value) if value.is_a?(Hash)
+        return parse(value) if provider.nil? && value.is_a?(String) && value.include?("/")
+
+        new(model_id: value, provider:)
+      end
+
+      def self.from_hash(value)
+        attributes = value.transform_keys(&:to_sym)
+        new(model_id: attributes[:model_id] || attributes[:model], provider: attributes[:provider])
+      end
+      private_class_method :from_hash
+
+      # Inverse of #to_s: the first slash separates provider from model,
+      # so a reference whose model id itself contains slashes round-trips
+      # ("openrouter/openai/gpt-5" -> provider :openrouter,
+      # model "openai/gpt-5"). An explicit `provider:` keyword keeps the
+      # string literal and is never re-split.
+      def self.parse(value)
+        provider, model_id = value.split("/", 2)
+        raise ArgumentError, "provider segment in #{value.inspect} must not be blank" if provider.empty?
+
+        new(model_id:, provider:)
+      end
+
+      def key
+        [provider, model_id].freeze
+      end
+
+      # True when the two references can address the same physical model:
+      # an unqualified reference delegates provider selection to RubyLLM,
+      # so it can resolve to any provider serving the same model id.
+      def same_candidate?(other)
+        model_id == other.model_id &&
+          (provider.nil? || other.provider.nil? || provider == other.provider)
+      end
+
+      def chat_options
+        { model: model_id, provider: }.compact.freeze
+      end
+
+      def to_s
+        provider ? "#{provider}/#{model_id}" : model_id
+      end
+    end
+  end
+end

data/lib/smith/agent/provider_attempt.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+
+require_relative "../types"
+require_relative "model_reference"
+
+module Smith
+  class Agent
+    class ProviderAttempt < Dry::Struct
+      attribute :completion, Types::Any.optional
+      attribute :model_reference, Types.Instance(ModelReference)
+      attribute :error, Types.Instance(StandardError).optional
+
+      def self.success(completion:, model_reference:)
+        new(completion:, model_reference:, error: nil)
+      end
+
+      def self.failure(error:, model_reference:)
+        new(completion: nil, model_reference:, error:)
+      end
+
+      def success?
+        error.nil?
+      end
+    end
+  end
+end

data/lib/smith/agent/provider_candidate_sequence.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Smith
+  class Agent
+    class ProviderCandidateSequence
+      include Enumerable
+
+      def initialize(references)
+        @references = references.freeze
+        @remaining_by_provider = references.each_with_object(Hash.new(0)) do |reference, counts|
+          counts[reference.provider] += 1
+        end
+        @unavailable_providers = {}
+        @available_count = references.length
+      end
+
+      # Returns self so an exhausted sequence can never be mistaken for
+      # an attempt result by a caller that forgets to fail closed.
+      def each
+        return enum_for(:each) unless block_given?
+
+        references.each_with_index do |reference, index|
+          consume(reference)
+          yield reference, index unless unavailable?(reference.provider)
+        end
+        self
+      end
+
+      def suppress(provider)
+        return unless provider
+        return if unavailable?(provider)
+
+        unavailable_providers[provider] = true
+        @available_count -= remaining_by_provider.fetch(provider, 0)
+      end
+
+      def fallback_available?
+        @available_count.positive?
+      end
+
+      private
+
+      attr_reader :references, :remaining_by_provider, :unavailable_providers
+
+      def consume(reference)
+        remaining_by_provider[reference.provider] -= 1
+        @available_count -= 1 unless unavailable?(reference.provider)
+      end
+
+      def unavailable?(provider)
+        unavailable_providers.key?(provider)
+      end
+    end
+  end
+end

data/lib/smith/agent/provider_completion.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "provider_failure_handling"
+require_relative "invocation_preparation"
+require_relative "provider_attempt"
+require_relative "provider_candidate_sequence"
+
+module Smith
+  class Agent
+    module ProviderCompletion
+      include ProviderFailureHandling
+      include InvocationPreparation
+
+      private
+
+      def complete_with_provider(agent_class, prepared_input, output_schema:)
+        candidates = ProviderCandidateSequence.new(build_model_chain(agent_class))
+        candidates.each do |model_reference, index|
+          check_deadline! if index.positive?
+          attempt = attempt_model(agent_class, prepared_input, model_reference, output_schema:)
+          return [attempt.completion, attempt.model_reference] if attempt.success?
+
+          candidates.suppress(account_failed_provider(attempt, model_reference))
+          handle_provider_failure!(
+            attempt.error, attempt.model_reference, agent_class,
+            fallback_available: candidates.fallback_available?
+          )
+        end
+
+        # Fail closed: an empty candidate chain (agent without a model)
+        # or any exhausted sequence must surface a typed diagnostic, not
+        # the sequence itself destructured into nils.
+        raise Smith::AgentError,
+              "no executable model candidate for #{agent_class}; declare a model or fallback_models"
+      end
+
+      # Suppression keys on the provider that actually rejected the
+      # account; when the chat is unobservable the attempted reference's
+      # declared provider is the best available attribution, so a dead
+      # account is not billed a second same-provider attempt.
+      def account_failed_provider(attempt, attempted_reference)
+        return unless provider_account_failure?(attempt.error)
+
+        attempt.model_reference.provider || attempted_reference.provider
+      end
+
+      def build_model_chain(agent_class)
+        references = [primary_model_reference(agent_class), *fallback_model_references(agent_class)].compact
+        references.each_with_object([]) do |reference, chain|
+          chain << reference unless chain.any? { |kept| kept.same_candidate?(reference) }
+        end
+      end
+
+      def primary_model_reference(agent_class)
+        return resolve_dynamic_model(agent_class) if agent_class.model_block
+
+        model_id = agent_class.chat_kwargs[:model]
+        return unless model_id
+
+        # Static declarations stay literal: RubyLLM owns the meaning of
+        # the declared id, so a slashed id ("openai/gpt-5") is not split
+        # into provider/model here the way ModelReference.coerce parses
+        # host-supplied strings.
+        ModelReference.new(model_id: model_id, provider: agent_class.chat_kwargs[:provider])
+      end
+
+      def fallback_model_references(agent_class)
+        Array(agent_class.fallback_models).map { |model| ModelReference.coerce(model) }
+      end
+
+      def resolve_dynamic_model(agent_class)
+        result = agent_class.model_block.call(@context || {})
+        reference = ModelReference.coerce(result)
+        return reference if reference.provider
+
+        raise Smith::AgentError,
+              "model block for #{agent_class} must return a provider-qualified model reference; got #{result.inspect}"
+      rescue ArgumentError, Dry::Struct::Error => e
+        raise Smith::AgentError, "invalid model block result for #{agent_class}: #{e.message}"
+      end
+
+      def attempt_model(agent_class, prepared_input, model_reference, output_schema:)
+        chat = prepared_attempt_chat(agent_class, prepared_input, model_reference, output_schema:)
+        message_count = chat_message_count(chat)
+        observed_reference = observed_model_reference(chat, fallback: model_reference)
+        completion = Completion.from_messages(response: chat.complete, messages: new_chat_messages(chat, message_count))
+
+        ProviderAttempt.success(completion:, model_reference: observed_reference)
+      rescue StandardError => e
+        observed_reference ||= observed_model_reference(chat, fallback: model_reference)
+        account_completed_prefix(agent_class, observed_reference, new_chat_messages(chat, message_count))
+        raise unless provider_failure?(e)
+
+        ProviderAttempt.failure(error: e, model_reference: observed_reference)
+      end
+
+      def observed_model_reference(chat, fallback:)
+        model = observable_model(chat)
+        return fallback unless model.respond_to?(:id) && !model.id.to_s.empty?
+
+        ModelReference.coerce(model.id, provider: observed_provider(model, fallback))
+      rescue StandardError
+        fallback
+      end
+
+      def observable_model(chat)
+        resolved_chat = chat.respond_to?(:to_llm) ? chat.to_llm : chat
+        resolved_chat.model if resolved_chat.respond_to?(:model)
+      end
+
+      def observed_provider(model, fallback)
+        model.respond_to?(:provider) && !model.provider.to_s.empty? ? model.provider : fallback.provider
+      end
+
+      def prepared_attempt_chat(agent_class, prepared_input, model_reference, output_schema:)
+        chat = agent_class.chat(**model_reference.chat_options, **bridge_workflow_inputs(agent_class))
+        add_prepared_input(chat, prepared_input)
+        output_schema ? chat.with_schema(output_schema) : chat
+      end
+
+      def chat_message_count(chat)
+        chat.respond_to?(:messages) ? chat.messages.length : nil
+      end
+
+      def new_chat_messages(chat, message_count)
+        message_count ? chat.messages.drop(message_count) : []
+      end
+    end
+  end
+end

data/lib/smith/agent/provider_failure_handling.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Smith
+  class Agent
+    module ProviderFailureHandling
+      TRANSIENT_ERRORS = [
+        RubyLLM::ServerError,
+        RubyLLM::ServiceUnavailableError,
+        RubyLLM::OverloadedError,
+        RubyLLM::RateLimitError
+      ].freeze
+      MODEL_UNAVAILABLE_STATUSES = [404, 410].freeze
+      PROVIDER_ACCOUNT_ERRORS = [
+        RubyLLM::UnauthorizedError,
+        RubyLLM::PaymentRequiredError
+      ].freeze
+      MODEL_PERMISSION_ERRORS = [RubyLLM::ForbiddenError].freeze
+
+      private_constant :TRANSIENT_ERRORS, :MODEL_UNAVAILABLE_STATUSES,
+                       :PROVIDER_ACCOUNT_ERRORS, :MODEL_PERMISSION_ERRORS
+
+      private
+
+      def handle_provider_failure!(error, model_reference, agent_class, fallback_available:)
+        account_failed_attempt(error, model_reference, agent_class)
+        if completed_tool_calls?
+          raise Smith::ToolOutcomeUncertain.new(
+            "provider failed after tool execution began; retry or fallback could replay an uncertain outcome"
+          ), cause: error
+        end
+        return if fallback_eligible?(error) && fallback_available
+
+        raise terminal_provider_error(error, model_reference), cause: error
+      end
+
+      def provider_failure?(error)
+        error.is_a?(RubyLLM::Error) ||
+          (defined?(RubyLLM::ModelNotFoundError) && error.is_a?(RubyLLM::ModelNotFoundError)) ||
+          error.is_a?(Faraday::TimeoutError) ||
+          error.is_a?(Faraday::ConnectionFailed)
+      end
+
+      def provider_account_failure?(error)
+        PROVIDER_ACCOUNT_ERRORS.any? { |error_class| error.is_a?(error_class) }
+      end
+
+      def completed_tool_calls?
+        Tool.current_tool_execution_tracker&.started?
+      end
+
+      def fallback_eligible?(error)
+        transient_failure?(error) ||
+          transport_failure?(error) ||
+          provider_account_failure?(error) ||
+          model_permission_failure?(error) ||
+          model_unavailable?(error)
+      end
+
+      def transient_failure?(error)
+        TRANSIENT_ERRORS.any? { |error_class| error.is_a?(error_class) }
+      end
+
+      def transport_failure?(error)
+        error.is_a?(Faraday::TimeoutError) || error.is_a?(Faraday::ConnectionFailed)
+      end
+
+      def model_permission_failure?(error)
+        MODEL_PERMISSION_ERRORS.any? { |error_class| error.is_a?(error_class) }
+      end
+
+      def model_unavailable?(error)
+        return true if defined?(RubyLLM::ModelNotFoundError) && error.is_a?(RubyLLM::ModelNotFoundError)
+        return false unless error.respond_to?(:response)
+
+        response = error.response
+        response.respond_to?(:status) && MODEL_UNAVAILABLE_STATUSES.include?(response.status.to_i)
+      rescue StandardError
+        false
+      end
+
+      def terminal_provider_error(error, model_reference)
+        return Smith::AgentError.new(error.message) if transient_failure?(error) || transport_failure?(error)
+
+        Smith::ProviderPermanentFailure.new(
+          error.message,
+          provider: model_reference.provider,
+          model_id: model_reference.model_id,
+          source_error_class: error.class.name
+        )
+      end
+    end
+  end
+end