smith-agents 0.6.1 → 0.8.0

data/lib/smith/tool.rb

@@ -4,15 +4,67 @@ require "ruby_llm"
 
 require_relative "tool/capability_builder"
 require_relative "tool/policy"
+require_relative "tool/call_budget"
+require_relative "tool/call_batch"
+require_relative "tool/legacy_call_allowance"
+require_relative "tool/call_allowance_counter"
+require_relative "tool/call_allowance"
+require_relative "tool/call_reservation"
+require_relative "tool/call_admission"
+require_relative "tool/execution_authority"
+require_relative "tool/execution_authorization"
+require_relative "tool/execution_tracker"
+require_relative "tool/execution_lifecycle"
+require_relative "tool/invocation"
+require_relative "tool/argument_snapshot_result"
+require_relative "tool/argument_scalar_snapshot"
+require_relative "tool/argument_container_reader"
+require_relative "tool/argument_snapshot_accounting"
+require_relative "tool/argument_snapshot_traversal"
+require_relative "tool/argument_snapshot"
+require_relative "tool/invocation_request"
+require_relative "tool/invocation_sequence"
+require_relative "tool/execution_batch_collection"
+require_relative "tool/execution_batch_invocations"
+require_relative "tool/execution_batch_source_metadata"
+require_relative "tool/execution_batch_source_call"
+require_relative "tool/execution_batch_sources"
+require_relative "tool/execution_batch_state"
+require_relative "tool/execution_batch"
+require_relative "tool/execution_batch_admission"
+require_relative "tool/execution_batch_requests"
+require_relative "tool/execution_batch_builder"
+require_relative "tool/execution_batch_registry"
 require_relative "tool/budget_enforcement"
+require_relative "tool_capture_failed"
 require_relative "tool/capture"
+require_relative "tool/capture_configuration"
 require_relative "tool/compatibility"
+require_relative "tool/scoped_context"
+require_relative "tool/bounded_completion_state"
+require_relative "tool/bounded_completion_guard"
+require_relative "tool/bounded_completion_controls"
+require_relative "tool/fail_fast_completion"
+require_relative "tool/graceful_completion"
+require_relative "tool/bounded_completion_context"
+require_relative "tool/bounded_completion_installation"
+require_relative "tool/execution_failure_handling"
+require_relative "tool/execution_dispatch"
+require_relative "tool/chat_execution_callbacks"
+require_relative "tool/execution_batch_lifecycle"
+require_relative "tool/chat_execution_context"
 
 module Smith
   class Tool < RubyLLM::Tool
     include Policy
+    include ExecutionAuthorization
+    include ExecutionLifecycle
     include BudgetEnforcement
     include Capture
+    extend CaptureConfiguration
+    extend ScopedContext
+
+    private_constant :ExecutionAuthority
 
     class << self
       # Tool subclasses inherit the parent's compatible_with spec by
@@ -40,46 +92,6 @@ module Smith
 
       attr_reader :compatible_with_spec
 
-      def current_guardrails
-        Thread.current[:smith_tool_guardrails]
-      end
-
-      def current_guardrails=(value)
-        Thread.current[:smith_tool_guardrails] = value
-      end
-
-      def current_deadline
-        Thread.current[:smith_tool_deadline]
-      end
-
-      def current_deadline=(value)
-        Thread.current[:smith_tool_deadline] = value
-      end
-
-      def current_ledger
-        Thread.current[:smith_tool_ledger]
-      end
-
-      def current_ledger=(value)
-        Thread.current[:smith_tool_ledger] = value
-      end
-
-      def current_tool_call_allowance
-        Thread.current[:smith_tool_call_allowance]
-      end
-
-      def current_tool_call_allowance=(value)
-        Thread.current[:smith_tool_call_allowance] = value
-      end
-
-      def current_tool_result_collector
-        Thread.current[:smith_tool_result_collector]
-      end
-
-      def current_tool_result_collector=(value)
-        Thread.current[:smith_tool_result_collector] = value
-      end
-
       def category(value = nil)
         return @category if value.nil?
 
@@ -105,32 +117,35 @@ module Smith
 
         @before_execute = block
       end
-
-      def capture_result(&block)
-        return @capture_result unless block_given?
-
-        @capture_result = block
-      end
     end
 
     def execute(**kwargs)
-      run_before_execute_hook!(kwargs)
-      check_tool_deadline!
-      check_privilege!(kwargs)
-      check_authorization!(kwargs)
-      run_tool_guardrails!(kwargs)
-      check_tool_deadline!
-      charge_tool_call!
-
-      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      result = perform(**kwargs)
-      duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+      authorize_tool_execution!
+      kwargs.freeze
+      prepare_tool_execution!(kwargs)
+      result, duration = perform_with_duration(kwargs)
 
       emit_tool_trace(kwargs, result, duration)
       capture_result_if_configured(kwargs, result)
       result
     end
 
+    protected
+
+    def invocation_argument_error(arguments) = validate_keyword_arguments(normalize_args(arguments))
+
+    def execute_keyword_signature
+      parameters = method(:perform).parameters
+      required_keywords = parameters.filter_map { |kind, name| name if kind == :keyreq }
+      optional_keywords = parameters.filter_map { |kind, name| name if kind == :key }
+      accepts_extra_keywords = parameters.any? { |kind, _| kind == :keyrest }
+      accepts_positional_arguments = parameters.any? do |kind, _|
+        RubyLLM::Tool::POSITIONAL_PARAMETER_KINDS.include?(kind)
+      end
+
+      [required_keywords, optional_keywords, accepts_extra_keywords, accepts_positional_arguments]
+    end
+
     private
 
     def run_before_execute_hook!(kwargs)
@@ -164,6 +179,12 @@ module Smith
       raise DeadlineExceeded, "wall_clock deadline exceeded during tool execution" if Time.now.utc >= deadline
     end
 
+    def check_dispatch_deadline!
+      check_tool_deadline!
+    rescue DeadlineExceeded
+      raise ToolDispatchRejected, "tool deadline expired before dispatch"
+    end
+
     def perform(**kwargs)
       raise NotImplementedError, "#{self.class} must implement #perform"
     end

data/lib/smith/tool_capture_failed.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "digest"
+
+require_relative "error"
+
+module Smith
+  class ToolCaptureFailed < Error
+    REASONS = %i[
+      collector_missing collector_invalid capture_empty capture_block_failed collector_failed
+    ].freeze
+    REASONS_BY_NAME = REASONS.to_h { |reason| [reason.to_s.freeze, reason] }.freeze
+    DETAIL_NAMES = %i[tool_name reason].freeze
+    DETAIL_KEYS = DETAIL_NAMES.to_h { |name| [name.to_s.freeze, name] }.freeze
+    MAX_TOOL_NAME_BYTES = 256
+    private_constant :REASONS, :REASONS_BY_NAME, :DETAIL_NAMES, :DETAIL_KEYS, :MAX_TOOL_NAME_BYTES
+
+    attr_reader :tool_name, :reason
+
+    def initialize(tool_name:, reason:)
+      @tool_name = normalize_tool_name(tool_name)
+      @reason = normalize_reason(reason)
+      super("strict result capture failed for #{@tool_name}: #{@reason}")
+    end
+
+    def details
+      { tool_name:, reason: }.freeze
+    end
+
+    def self.from_details(details)
+      values = normalize_details(details)
+      new(tool_name: values.fetch(:tool_name), reason: values.fetch(:reason))
+    end
+
+    def self.for_runtime(tool_name:, reason:)
+      new(tool_name:, reason:)
+    rescue ArgumentError
+      new(tool_name: diagnostic_tool_name(tool_name), reason:)
+    end
+
+    def self.normalize_details(details)
+      raise ArgumentError, "tool capture failure details must be a Hash" unless details.is_a?(Hash)
+
+      values = {}
+      Hash.instance_method(:each_pair).bind_call(details) do |key, value|
+        name = normalize_detail_name(key)
+        unless DETAIL_NAMES.include?(name)
+          raise ArgumentError, "tool capture failure details contain an unknown attribute"
+        end
+        raise ArgumentError, "tool capture failure details contain a duplicate attribute" if values.key?(name)
+
+        values[name] = value
+      end
+      missing = DETAIL_NAMES - values.keys
+      raise ArgumentError, "tool capture failure details are missing required attributes" if missing.any?
+
+      values
+    end
+
+    def self.normalize_detail_name(key)
+      return key if key.is_a?(Symbol)
+
+      DETAIL_KEYS[key] if key.is_a?(String)
+    end
+
+    def self.diagnostic_tool_name(value)
+      bytes = value.to_s.b
+      return "anonymous_tool" if bytes.empty?
+
+      "tool_#{Digest::SHA256.hexdigest(bytes)}"
+    end
+    private_class_method :normalize_details, :normalize_detail_name, :diagnostic_tool_name
+
+    private
+
+    def normalize_tool_name(value)
+      unless value.is_a?(String) || value.is_a?(Symbol)
+        raise ArgumentError, "tool capture failure tool name must be a String or Symbol"
+      end
+
+      name = value.to_s
+      raise ArgumentError, "tool capture failure tool name must be valid UTF-8" unless name.valid_encoding?
+
+      name = name.encode(Encoding::UTF_8)
+      raise ArgumentError, "tool capture failure tool name must be valid UTF-8" unless name.valid_encoding?
+
+      unless name.bytesize.between?(1, MAX_TOOL_NAME_BYTES)
+        raise ArgumentError, "tool capture failure tool name must be a bounded non-empty value"
+      end
+
+      name.dup.freeze
+    rescue EncodingError
+      raise ArgumentError, "tool capture failure tool name must be valid UTF-8"
+    end
+
+    def normalize_reason(value)
+      unless value.is_a?(String) || value.is_a?(Symbol)
+        raise ArgumentError, "tool capture failure reason must be a String or Symbol"
+      end
+
+      REASONS_BY_NAME.fetch(value.to_s) do
+        raise ArgumentError, "tool capture failure reason is not recognized"
+      end
+    end
+  end
+end

data/lib/smith/tool_execution_not_admitted.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "error"
+
+module Smith
+  class ToolExecutionNotAdmitted < Error; end
+end

data/lib/smith/tool_failure_notification_failed.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "error"
+require_relative "diagnostic_text"
+
+module Smith
+  class ToolFailureNotificationFailed < Error
+    DETAIL_NAMES = %i[
+      dispatch_error_class dispatch_error_message notification_error_class notification_error_message
+    ].freeze
+    DETAIL_KEYS = DETAIL_NAMES.to_h { |name| [name.to_s.freeze, name] }.freeze
+    EXCEPTION_MESSAGE = Exception.instance_method(:message)
+    MODULE_NAME = Module.instance_method(:name)
+    OBJECT_CLASS = Object.instance_method(:class)
+    private_constant :DETAIL_NAMES, :DETAIL_KEYS, :EXCEPTION_MESSAGE, :MODULE_NAME, :OBJECT_CLASS
+
+    attr_reader :details, :dispatch_error, :notification_error
+
+    def initialize(dispatch_error:, notification_error:)
+      @dispatch_error = dispatch_error
+      @notification_error = notification_error
+      @details = build_details
+      super(
+        "host failed to record a terminal tool outcome: " \
+        "#{@details.fetch(:notification_error_class)}: #{@details.fetch(:notification_error_message)}"
+      )
+    end
+
+    def build_details
+      {
+        dispatch_error_class: DiagnosticText.capture(error_class_name(dispatch_error), max_bytes: 512),
+        dispatch_error_message: DiagnosticText.capture(error_message(dispatch_error)),
+        notification_error_class: DiagnosticText.capture(error_class_name(notification_error), max_bytes: 512),
+        notification_error_message: DiagnosticText.capture(error_message(notification_error))
+      }.freeze
+    end
+    private :build_details
+
+    def self.from_details(details)
+      values = normalize_details(details)
+      new(
+        dispatch_error: restored_error(values, :dispatch_error),
+        notification_error: restored_error(values, :notification_error)
+      )
+    end
+
+    def self.normalize_details(details)
+      raise ArgumentError, "tool failure notification details must be a Hash" unless details.is_a?(Hash)
+
+      values = details.each_with_object({}) do |(key, value), normalized|
+        append_detail!(normalized, key, value)
+      end
+      validate_complete!(values)
+      values.freeze
+    end
+
+    def self.append_detail!(normalized, key, value)
+      name = normalize_detail_name(key)
+      raise ArgumentError, "tool failure notification details contain an unknown attribute" unless name
+      raise ArgumentError, "tool failure notification details contain a duplicate attribute" if normalized.key?(name)
+      raise ArgumentError, "tool failure notification detail values must be strings" unless value.is_a?(String)
+
+      normalized[name] = value
+    end
+
+    def self.validate_complete!(values)
+      missing = DETAIL_NAMES - values.keys
+      raise ArgumentError, "tool failure notification details are missing required attributes" if missing.any?
+    end
+
+    def self.normalize_detail_name(key)
+      return key if key.is_a?(Symbol) && DETAIL_NAMES.include?(key)
+
+      DETAIL_KEYS[key] if key.is_a?(String)
+    end
+
+    def self.restored_error(values, prefix)
+      RuntimeError.new(
+        "#{values.fetch(:"#{prefix}_class")}: #{values.fetch(:"#{prefix}_message")}"
+      )
+    end
+
+    def error_class_name(error)
+      error_class = OBJECT_CLASS.bind_call(error)
+      MODULE_NAME.bind_call(error_class) || MODULE_NAME.bind_call(error_class.superclass) || "StandardError"
+    end
+
+    def error_message(error) = EXCEPTION_MESSAGE.bind_call(error)
+    private :error_class_name, :error_message
+
+    private_class_method :normalize_details, :append_detail!, :validate_complete!, :normalize_detail_name,
+                         :restored_error
+  end
+end

data/lib/smith/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Smith
-  VERSION = "0.6.1"
-  EXECUTION_SEMANTICS_VERSION = "2"
+  VERSION = "0.8.0"
+  EXECUTION_SEMANTICS_VERSION = "5"
 end

data/lib/smith/workflow/agent_result.rb

@@ -4,16 +4,17 @@ module Smith
   class Workflow
     # rubocop:disable Style/RedundantStructKeywordInit
     AgentResult = Struct.new(
-      :content, :input_tokens, :output_tokens, :cost, :model_used,
+      :content, :input_tokens, :output_tokens, :cost, :model_used, :provider_used,
       keyword_init: true
     ) do
-      def self.from_response(response, content, model_used: nil)
+      def self.from_response(response, content, model_used: nil, provider_used: nil)
         new(
           content: content,
           input_tokens: response.respond_to?(:input_tokens) ? response.input_tokens : nil,
           output_tokens: response.respond_to?(:output_tokens) ? response.output_tokens : nil,
           cost: nil,
-          model_used: model_used
+          model_used: model_used,
+          provider_used: provider_used
         )
       end
 

data/lib/smith/workflow/artifact_integration.rb

@@ -33,7 +33,8 @@ module Smith
         Context::Session.new(
           messages: messages,
           context_manager: manager,
-          persisted_context: @context
+          persisted_context: @context,
+          seed_message_count: @seed_message_count || 0
         )
       end
     end

data/lib/smith/workflow/composite/branch_failure.rb

@@ -12,21 +12,29 @@ module Smith
           "error_class" => :error_class,
           "error_family" => :error_family,
           "retryable" => :retryable,
-          "kind" => :kind
+          "kind" => :kind,
+          "tool_name" => :tool_name,
+          "reason" => :reason
         }.freeze
-        DETAIL_NAMES = DETAIL_KEYS.values.freeze
-        private_constant :DETAIL_KEYS, :DETAIL_NAMES
+        REQUIRED_DETAIL_NAMES = %i[branch_key error_class error_family retryable kind].freeze
+        OPTIONAL_DETAIL_NAMES = %i[tool_name reason].freeze
+        DETAIL_NAMES = (REQUIRED_DETAIL_NAMES + OPTIONAL_DETAIL_NAMES).freeze
+        private_constant :DETAIL_KEYS, :REQUIRED_DETAIL_NAMES, :OPTIONAL_DETAIL_NAMES, :DETAIL_NAMES
 
-        attr_reader :branch_key, :error_class, :error_family, :retryable, :kind, :details
+        attr_reader :branch_key, :error_class, :error_family, :retryable, :kind, :tool_name, :reason, :details
 
         def self.from_details(details)
           values = normalize_details(details)
-          error = Error.new(
+          error_attributes = {
             class_name: values.fetch(:error_class),
             family: values.fetch(:error_family),
             retryable: values.fetch(:retryable),
             kind: values.fetch(:kind)
-          )
+          }
+          OPTIONAL_DETAIL_NAMES.each do |name|
+            error_attributes[name] = values[name] if values.key?(name)
+          end
+          error = Error.new(error_attributes)
           new(branch_key: values.fetch(:branch_key), error:)
         end
 
@@ -42,7 +50,7 @@ module Smith
 
             normalized[name] = value
           end
-          missing = DETAIL_NAMES - normalized.keys
+          missing = REQUIRED_DETAIL_NAMES - normalized.keys
           raise ArgumentError, "composite branch failure details are missing required attributes" if missing.any?
 
           normalized
@@ -60,10 +68,7 @@ module Smith
         def initialize(branch_key:, error:)
           validate_arguments!(branch_key, error)
           @branch_key = branch_key.dup.freeze
-          @error_class = error.class_name.dup.freeze
-          @error_family = error.family.dup.freeze
-          @retryable = error.retryable
-          @kind = error.kind&.dup&.freeze
+          copy_error_attributes(error)
           @details = failure_details
           super("composite branch #{branch_key.inspect} failed")
         end
@@ -76,14 +81,30 @@ module Smith
           raise ArgumentError, "composite branch failure requires typed error evidence" unless error.is_a?(Error)
         end
 
+        def copy_error_attributes(error)
+          @error_class = owned_string(error.class_name)
+          @error_family = owned_string(error.family)
+          @retryable = error.retryable
+          @kind = owned_string(error.kind)
+          @tool_name = owned_string(error.tool_name)
+          @reason = owned_string(error.reason)
+        end
+
+        def owned_string(value)
+          value&.dup&.freeze
+        end
+
         def failure_details
-          {
+          values = {
             branch_key: @branch_key,
             error_class: @error_class,
             error_family: @error_family,
             retryable: @retryable,
             kind: @kind
-          }.freeze
+          }
+          values[:tool_name] = @tool_name if @tool_name
+          values[:reason] = @reason if @reason
+          values.freeze
         end
       end
     end

data/lib/smith/workflow/composite/branch_outcome.rb

@@ -82,6 +82,12 @@ module Smith
           def serializable(values)
             values.merge(error: values[:error]&.to_h, effects: values.fetch(:effects).to_h)
           end
+
+          def legacy_serializable(values)
+            serializable(values).tap do |payload|
+              payload[:error] = payload[:error]&.except(:tool_name, :reason)
+            end
+          end
         end
 
         def initialize(attributes)
@@ -89,8 +95,7 @@ module Smith
           owned[:output] = self.class.send(:normalize_output, owned[:output])
           super(owned)
           validate_shape!
-          expected = PayloadDigest.call(self.class.send(:serializable, to_h.except(:digest)))
-          raise ArgumentError, "composite branch outcome digest does not match" unless digest == expected
+          validate_digest!
         end
 
         def succeeded? = status == :succeeded
@@ -98,6 +103,18 @@ module Smith
 
         private
 
+        def validate_digest!
+          values = to_h.except(:digest)
+          payloads = [self.class.send(:serializable, values)]
+          payloads << self.class.send(:legacy_serializable, values) if legacy_digest_allowed?
+          expected = payloads.map { PayloadDigest.call(_1) }
+          raise ArgumentError, "composite branch outcome digest does not match" unless expected.include?(digest)
+        end
+
+        def legacy_digest_allowed?
+          error.nil? || (error.tool_name.nil? && error.reason.nil?)
+        end
+
         def validate_shape!
           valid = succeeded? ? error.nil? : error && output.nil?
           raise ArgumentError, "composite branch outcome fields do not match status" unless valid

data/lib/smith/workflow/composite/effects.rb

@@ -13,7 +13,7 @@ module Smith
         attr_reader :total_tokens, :total_cost
 
         USAGE_ATTRIBUTES = %w[
-          usage_id agent_name model input_tokens output_tokens cost attempt_kind recorded_at
+          usage_id agent_name model provider input_tokens output_tokens cost attempt_kind recorded_at
         ].freeze
         TOOL_ATTRIBUTES = %w[tool captured].freeze
         private_constant :USAGE_ATTRIBUTES, :TOOL_ATTRIBUTES
@@ -70,6 +70,8 @@ module Smith
         def validate_usage_identity!(entry)
           validate_usage_id!(entry.fetch("usage_id"))
           validate_agent_name!(entry.fetch("agent_name"))
+          provider = entry.fetch("provider")
+          validate_nonempty_string!(provider, "composite usage entry provider") if provider
           %w[model attempt_kind recorded_at].each do |key|
             validate_nonempty_string!(entry.fetch(key), "composite usage entry #{key}")
           end

data/lib/smith/workflow/composite/error.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../types"
+require_relative "../../tool_capture_failed"
 require_relative "payload"
 
 module Smith
@@ -8,12 +9,15 @@ module Smith
     module Composite
       class Error < Payload
         FAMILIES = %w[
-          tool_guardrail_failed deterministic_step_failure deadline_exceeded
-          agent_error workflow_error other
+          tool_capture_failed tool_guardrail_failed deterministic_step_failure
+          deadline_exceeded agent_error workflow_error other
         ].freeze
         ALWAYS_RETRYABLE_FAMILIES = %w[deadline_exceeded agent_error].freeze
         CONDITIONALLY_RETRYABLE_FAMILIES = %w[tool_guardrail_failed deterministic_step_failure].freeze
+        OPTIONAL_METADATA = %i[tool_name reason].freeze
+        STRING_METADATA = %i[kind tool_name reason].freeze
         private_constant :ALWAYS_RETRYABLE_FAMILIES, :CONDITIONALLY_RETRYABLE_FAMILIES
+        private_constant :OPTIONAL_METADATA, :STRING_METADATA
         OwnedString = Types::String.constructor { |value| value.is_a?(String) ? value.dup.freeze : value }
         private_constant :OwnedString
 
@@ -21,17 +25,43 @@ module Smith
         attribute :family, OwnedString.enum(*FAMILIES)
         attribute :retryable, Types::Bool
         attribute? :kind, OwnedString.constrained(min_size: 1, max_size: 128).optional
+        attribute? :tool_name, OwnedString.constrained(min_size: 1, max_size: 256).optional
+        attribute? :reason, OwnedString.constrained(min_size: 1, max_size: 128).optional
+
+        class << self
+          def normalize_attributes(attributes)
+            return super unless attributes.is_a?(Hash)
+
+            super(attributes_with_optional_metadata(attributes))
+          end
+
+          private
+
+          def attributes_with_optional_metadata(attributes)
+            values = {}
+            Hash.instance_method(:each_pair).bind_call(attributes) { |key, value| values[key] = value }
+            OPTIONAL_METADATA.each do |name|
+              values[name] = nil unless values.key?(name) || values.key?(name.to_s)
+            end
+            values
+          end
+        end
 
         def initialize(attributes)
-          owned = self.class.normalize_attributes(attributes)
-          owned[:kind] = owned[:kind].to_s if owned[:kind]
-          super(owned)
+          super(normalize_error_attributes(attributes))
           validate_retryability!
           validate_kind!
+          validate_tool_capture_metadata!
         end
 
         private
 
+        def normalize_error_attributes(attributes)
+          self.class.normalize_attributes(attributes).tap do |normalized|
+            STRING_METADATA.each { |name| normalized[name] = normalized[name].to_s if normalized[name] }
+          end
+        end
+
         def validate_retryability!
           valid = if ALWAYS_RETRYABLE_FAMILIES.include?(family)
                     retryable
@@ -48,6 +78,24 @@ module Smith
 
           raise ArgumentError, "composite error kind is not valid for its family"
         end
+
+        def validate_tool_capture_metadata!
+          valid = if family == "tool_capture_failed"
+                    valid_tool_capture_metadata?
+                  else
+                    tool_name.nil? && reason.nil?
+                  end
+          return if valid
+
+          raise ArgumentError, "composite error tool metadata does not match its family"
+        end
+
+        def valid_tool_capture_metadata?
+          ToolCaptureFailed.from_details(tool_name:, reason:)
+          true
+        rescue ArgumentError
+          false
+        end
       end
     end
   end