smith-agents 0.10.0 → 0.12.0

data/lib/smith/agent/usage_tracking.rb

@@ -13,61 +13,70 @@ module Smith
 
       private
 
+      # A failed attempt's own reported usage, cache counts included, is
+      # recorded, priced and settled into the budget like any billed
+      # response, so its usage entry agrees with its :provider_call trace.
       def account_failed_attempt(error, model_reference, agent_class, attempt_id: nil)
-        return unless error.respond_to?(:input_tokens) && error.respond_to?(:output_tokens)
+        usage = ProviderUsage.from_message(error)
+        return unless usage
 
-        input = error.input_tokens
-        output = error.output_tokens
-        return unless input.is_a?(Integer) && output.is_a?(Integer)
+        record_billed_usages(agent_class, [usage], :failed_attempt, model_reference, attempt_id:)
+      end
 
-        record_failed_usage(agent_class, model_reference, input, output, attempt_id:)
+      # The completed rounds of a tool loop whose attempt then failed were
+      # billed: they are recorded and settled into the budget like a failed
+      # attempt's usage. Returns the provider usages recorded, so the
+      # attempt's trace carries the same totals its usage entries hold.
+      def account_completed_prefix(agent_class, model_reference, messages, attempt_id: nil, stream_rounds: nil)
+        stream = stream_rounds && { rounds: stream_rounds, output_limit: nil }
+        completion = Completion.from_messages(response: nil, messages:, stream:)
+        record_billed_usages(agent_class, completion.provider_usages, :partial_attempt, model_reference, attempt_id:)
+        completion.provider_usages
       end
 
-      def account_completed_prefix(agent_class, model_reference, messages, attempt_id: nil)
-        completion = Completion.from_messages(response: nil, messages: messages)
-        record_completion_usage(agent_class, completion, :partial_attempt, model_reference, attempt_id:)
+      # Usage that is billed but is not the invocation's result joins the
+      # failed billable attempts, which budget settlement reads beside it.
+      def record_billed_usages(agent_class, usages, attempt_kind, model_reference, attempt_id:)
+        results = record_response_usages(agent_class, usages, attempt_kind, model_reference, attempt_id:)
+        add_failed_agent_results(results)
       end
 
-      def record_failed_usage(agent_class, model_reference, input_tokens, output_tokens, attempt_id: nil)
-        model_reference = coerce_model_reference(model_reference)
-        cost = Smith::Pricing.compute_cost(
-          model: model_reference.model_id,
-          provider: model_reference.provider,
-          input_tokens:,
-          output_tokens:
-        )
-        agent_result = Workflow::AgentResult.new(
-          content: nil,
-          input_tokens:,
-          output_tokens:,
-          cost: cost,
-          model_used: model_reference.model_id,
-          provider_used: model_reference.provider
-        )
-        Thread.current[:smith_failed_agent_results] ||= []
-        Thread.current[:smith_failed_agent_results] << agent_result
-        record_usage(agent_class, agent_result, :failed_attempt, model_reference, attempt_id:)
+      # A new Array, never the one in place: a step's thread context
+      # (ThreadContextSnapshot) puts back the list it started with, which
+      # must not carry this step's failed attempts into the next.
+      def add_failed_agent_results(results)
+        Thread.current[:smith_failed_agent_results] = [*Array(Thread.current[:smith_failed_agent_results]), *results]
       end
 
-      def snapshot_and_finalize(agent_class, completion, model_reference, attempt_id: nil)
+      # Records and settles one completed attempt's usage and returns its
+      # result, whether or not the result becomes the output.
+      def account_attempt(agent_class, completion, model_reference, attempt_id: nil)
         model_reference = coerce_model_reference(model_reference)
-        agent_result = Workflow::AgentResult.new(
-          content: completion.content,
-          input_tokens: completion.input_tokens,
-          output_tokens: completion.output_tokens,
-          cost: nil,
-          model_used: model_reference.model_id,
-          provider_used: model_reference.provider
-        )
+        agent_result = completion_agent_result(completion, model_reference)
         Thread.current[:smith_last_agent_result] = agent_result
         emit_token_usage(agent_result)
         account_completion!(agent_class, completion, model_reference, agent_result, attempt_id)
+        agent_result
+      end
 
-        agent_result.content = run_after_completion(agent_class, agent_result.content, @context)
+      # The output has been through `after_completion` (OutputIntegrity).
+      def finalize_output(agent_class, agent_result)
         raise_blank_output!(agent_class, agent_result)
         agent_result
       end
 
+      def completion_agent_result(completion, model_reference)
+        Workflow::AgentResult.new(
+          content: completion.content,
+          input_tokens: completion.input_tokens,
+          output_tokens: completion.output_tokens,
+          cost: nil,
+          model_used: model_reference.model_id,
+          provider_used: model_reference.provider,
+          **Workflow::AgentResult.usage_details(completion.usage)
+        )
+      end
+
       def raise_blank_output!(agent_class, agent_result)
         return unless blank_agent_output?(agent_result.content)
 
@@ -90,26 +99,33 @@ module Smith
       # budget settlement and result surfaces read) and the recorded entries,
       # the budget ledger, and the :cost trace all agree. The trace emits
       # only for fully metered, fully priced invocations, so a partial
-      # figure is never presented as the invocation cost; the partial sum
-      # still settles the budget because it is what was verifiably billed.
+      # figure is never presented as the invocation cost; the partial sums
+      # of cost and tokens still settle the budget because they are what
+      # was verifiably billed.
       def account_completion!(agent_class, completion, model_reference, agent_result, attempt_id)
-        invocation_cost, fully_priced = record_completion_usage(
+        invocation_cost, fully_priced, results = record_completion_usage(
           agent_class, completion, :completed_attempt, model_reference, attempt_id:
         )
         agent_result.cost = invocation_cost
-        emit_cost_trace(agent_result, invocation_cost) if fully_priced
+        agent_result.metered_tokens = results.sum(&:total_tokens) unless completion.usage_complete
+        return unless fully_priced
+
+        emit_cost_trace(agent_result, invocation_cost, cache_unpriced: results.any?(&:cache_unpriced))
       end
 
+      # Prices the result and notes whether cache tokens were priced at 0
+      # for lack of a rate, which the :cost trace reports.
       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,
-          provider: agent_result.provider_used,
-          input_tokens: agent_result.input_tokens,
-          output_tokens: agent_result.output_tokens
-        )
+        usage = {
+          model: agent_result.model_used, provider: agent_result.provider_used,
+          input_tokens: agent_result.input_tokens, output_tokens: agent_result.output_tokens,
+          cache_read_tokens: agent_result.cache_read_tokens || 0,
+          cache_write_tokens: agent_result.cache_write_tokens || 0
+        }
+        agent_result.cost = Smith::Pricing.compute_cost(**usage, mode: agent_result.mode || :sync)
+        agent_result.cache_unpriced = Smith::Pricing.cache_unpriced?(**usage.except(:output_tokens))
       end
     end
   end

data/lib/smith/agent.rb

@@ -11,9 +11,10 @@ module Smith
     EXECUTION_IDENTITY_UNSET = Object.new.freeze
     TOOL_BUDGET_EXHAUSTION_UNSET = Object.new.freeze
     TOOL_BUDGET_EXHAUSTION_POLICIES = %i[raise complete].freeze
+    BUDGET_KEYS = %i[token_limit cost wall_clock tool_calls total_tokens total_cost].freeze
 
     private_constant :EXECUTION_IDENTITY_UNSET
-    private_constant :TOOL_BUDGET_EXHAUSTION_UNSET, :TOOL_BUDGET_EXHAUSTION_POLICIES
+    private_constant :TOOL_BUDGET_EXHAUSTION_UNSET, :TOOL_BUDGET_EXHAUSTION_POLICIES, :BUDGET_KEYS
 
     # Reserved input names auto-injected by the normalizer into
     # runtime_context. User-side `inputs :name` calls cannot redeclare
@@ -30,8 +31,12 @@ module Smith
         subclass.instance_variable_set(:@output_schema_class, @output_schema_class)
         subclass.instance_variable_set(:@data_volume, @data_volume)
         subclass.instance_variable_set(:@fallback_models_list, @fallback_models_list&.dup&.freeze)
+        subclass.instance_variable_set(:@fallback_models_block, @fallback_models_block)
         subclass.instance_variable_set(:@model_block, @model_block)
         subclass.instance_variable_set(:@tool_budget_exhaustion, @tool_budget_exhaustion)
+        %i[@on_truncation @on_refusal @output_contract @output_repairs].each do |name|
+          subclass.instance_variable_set(name, instance_variable_get(name))
+        end
         subclass.instance_variable_set(:@execution_identity, nil)
         subclass.instance_variable_set(:@registered_name, nil)
       end
@@ -48,6 +53,12 @@ module Smith
       def budget(**opts)
         return @budget_config if opts.empty?
 
+        unknown = opts.keys - BUDGET_KEYS
+        unless unknown.empty?
+          raise ArgumentError, "agent budget does not accept #{unknown.map(&:inspect).join(", ")}; " \
+                               "accepted keys are #{BUDGET_KEYS.map(&:inspect).join(", ")}"
+        end
+
         @budget_config = opts
       end
 
@@ -140,8 +151,10 @@ require_relative "agent/dynamic_configuration"
 require_relative "agent/fallback_configuration"
 require_relative "agent/reserved_input_bridge"
 require_relative "agent/chat_construction"
+require_relative "agent/output_policy"
 
 Smith::Agent.extend(Smith::Agent::DynamicConfiguration)
 Smith::Agent.extend(Smith::Agent::FallbackConfiguration)
 Smith::Agent.extend(Smith::Agent::ReservedInputBridge)
 Smith::Agent.extend(Smith::Agent::ChatConstruction)
+Smith::Agent.extend(Smith::Agent::OutputPolicy)

data/lib/smith/artifacts/active_record_store.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require_relative "store_rules"
+
+module Smith
+  module Artifacts
+    # An artifact store in a database table, through the host's Active
+    # Record model (a class or its name):
+    #
+    #   create_table :smith_artifacts do |t|
+    #     t.string :ref, null: false, index: { unique: true }
+    #     t.binary :data, null: false, limit: 64.megabytes   # MySQL's blob holds 64 KiB
+    #     t.string :content_type, null: false
+    #     t.string :execution_namespace, index: true
+    #     t.timestamps
+    #   end
+    #
+    # Each artifact is one row, its ref a random UUID (after the store's
+    # tenant `namespace:` when one is set), with the run that stored it, so
+    # the store can say which run stored a ref.
+    class ActiveRecordStore
+      include StoreRules
+
+      INNER_REF = StoreRules::UUID
+
+      def initialize(model:, namespace: nil)
+        @model_source = model.is_a?(String) ? model.dup.freeze : model
+        @namespace = check_namespace!(namespace)
+      end
+
+      def store(data, content_type: "application/octet-stream", execution_namespace: nil)
+        enforce_tenant_isolation!
+        check_data!(data)
+        ref = generate_ref(SecureRandom.uuid)
+        model_class.create!(ref:, data:, content_type:, execution_namespace:)
+        ref
+      end
+
+      def fetch(ref)
+        enforce_tenant_isolation!
+        model_class.find_by(ref:)&.data if owns_ref?(ref)
+      end
+
+      # Whether a run (its execution namespace) stored this ref.
+      def stored_by?(ref, execution_namespace)
+        !execution_namespace.nil? && owns_ref?(ref) && model_class.where(ref:, execution_namespace:).exists?
+      end
+
+      def model = model_class
+
+      def expired(retention: nil, execution_namespace: nil)
+        retention = effective_retention(retention)
+        return [] unless retention
+
+        scope = model_class.where(model_class.arel_table[:created_at].lt(Time.now.utc - retention))
+        scope = scope.where(execution_namespace:) if execution_namespace
+        scope.pluck(:ref).select { |ref| owns_ref?(ref) }
+      end
+
+      # Removes the artifact (when a run is named, only if that run stored
+      # it).
+      def delete(ref, execution_namespace: nil)
+        enforce_tenant_isolation!
+        return unless owns_ref?(ref)
+
+        scope = model_class.where(ref:)
+        scope = scope.where(execution_namespace:) if execution_namespace
+        scope.delete_all
+        nil
+      end
+
+      private
+
+      def model_class = @model_source.is_a?(String) ? Object.const_get(@model_source) : @model_source
+    end
+  end
+end

data/lib/smith/artifacts/file.rb

@@ -1,38 +1,71 @@
 # frozen_string_literal: true
 
-require "securerandom"
+require "fileutils"
 require "json"
+require "securerandom"
+
+require_relative "store_rules"
 
 module Smith
   module Artifacts
+    # An artifact store in a directory (`dir:`), shared only when the
+    # directory is. Each artifact is a file named by a random UUID (after
+    # the store's tenant `namespace:` when one is set) beside a `.meta`
+    # file with its type and the run that stored it; no ref names any other
+    # file.
     class File
+      include StoreRules
+
+      INNER_REF = StoreRules::UUID
+
       def initialize(dir:, namespace: nil)
         @dir = dir
-        @namespace = namespace
+        @namespace = check_namespace!(namespace)
       end
 
       def store(data, content_type: "application/octet-stream", execution_namespace: nil)
-        ref = generate_ref
+        enforce_tenant_isolation!
+        check_data!(data)
+        ref = generate_ref(SecureRandom.uuid)
         meta = { content_type: content_type }
         meta[:execution_namespace] = execution_namespace if execution_namespace
-        ::File.write(::File.join(@dir, ref), data)
+        ::File.binwrite(::File.join(@dir, ref), data)
         ::File.write(::File.join(@dir, "#{ref}.meta"), JSON.generate(meta))
         ref
       end
 
       def fetch(ref)
+        enforce_tenant_isolation!
+        return unless owns_ref?(ref)
+
         path = ::File.join(@dir, ref)
-        ::File.exist?(path) ? ::File.read(path) : nil
+        ::File.binread(path) if ::File.file?(path)
+      end
+
+      # Removes the artifact (when a run is named, only if that run stored
+      # it).
+      def delete(ref, execution_namespace: nil)
+        enforce_tenant_isolation!
+        return unless owns_ref?(ref) && (execution_namespace.nil? || stored_by?(ref, execution_namespace))
+
+        [ref, "#{ref}.meta"].each { |name| ::FileUtils.rm_f(::File.join(@dir, name)) }
+        nil
+      end
+
+      # Whether a run (its execution namespace) stored this ref.
+      def stored_by?(ref, execution_namespace)
+        !execution_namespace.nil? && owns_ref?(ref) && stored_namespace(ref) == execution_namespace
       end
 
       def expired(retention: nil, execution_namespace: nil)
+        retention = effective_retention(retention)
         return [] unless retention
 
         cutoff = Time.now.utc - retention
-        Dir.glob(::File.join(@dir, "*")).reject { |f| f.end_with?(".meta") }.filter_map do |path|
+        Dir.glob(::File.join(@dir, "*")).filter_map do |path|
           ref = ::File.basename(path)
-          next unless ::File.mtime(path).utc < cutoff
-          next if execution_namespace && !matches_execution_namespace?(ref, execution_namespace)
+          next unless owns_ref?(ref) && ::File.mtime(path).utc < cutoff
+          next if execution_namespace && stored_namespace(ref) != execution_namespace
 
           ref
         end
@@ -40,19 +73,13 @@ module Smith
 
       private
 
-      def generate_ref
-        raw = SecureRandom.uuid
-        @namespace ? "#{@namespace}:#{raw}" : raw
-      end
-
-      def matches_execution_namespace?(ref, execution_namespace)
+      def stored_namespace(ref)
         meta_path = ::File.join(@dir, "#{ref}.meta")
-        return false unless ::File.exist?(meta_path)
+        return unless ::File.exist?(meta_path)
 
-        meta = JSON.parse(::File.read(meta_path), symbolize_names: true)
-        meta[:execution_namespace] == execution_namespace
+        JSON.parse(::File.read(meta_path))["execution_namespace"]
       rescue JSON::ParserError
-        false
+        nil
       end
     end
   end

data/lib/smith/artifacts/memory.rb

@@ -2,73 +2,84 @@
 
 require "digest"
 
+require_relative "store_rules"
+
 module Smith
   module Artifacts
+    # An artifact store in the process: for one process and for tests.
+    # Refs are content hashes, so runs that store the same bytes share one;
+    # each run's claim on it (and when it made the claim) is kept apart, so
+    # a run's delete drops only its own claim, and the bytes go with the
+    # last claim.
     class Memory
+      include StoreRules
+
+      INNER_REF = /\A\h{64}\z/
+      HOST = :host
+      private_constant :HOST
+
       attr_reader :namespace
 
       def initialize(namespace: nil)
-        @namespace = namespace
+        @namespace = check_namespace!(namespace)
         @store = {}
         @metadata = {}
       end
 
       def store(data, content_type: "application/octet-stream", execution_namespace: nil)
         enforce_tenant_isolation!
-        ref = generate_ref(data)
+        check_data!(data)
+        ref = generate_ref(Digest::SHA256.hexdigest(data))
         @store[ref] = data
-        @metadata[ref] ||= { content_type: content_type, stored_at: Time.now.utc, execution_namespaces: [] }
-        tag_execution_namespace(ref, execution_namespace)
+        meta = (@metadata[ref] ||= { content_type:, claims: {} })
+        meta[:claims][execution_namespace || HOST] = Time.now.utc
         ref
       end
 
       def fetch(ref)
         enforce_tenant_isolation!
-        return nil unless owns_ref?(ref)
-
-        @store[ref]
-      end
-
-      def expired(retention: nil, execution_namespace: nil)
-        effective_retention = retention || Smith.config.artifact_retention
-        return [] unless effective_retention
-
-        cutoff = Time.now.utc - effective_retention
-        @metadata.select { |ref, meta| expired_match?(ref, meta, cutoff, execution_namespace) }.keys
+        @store[ref] if owns_ref?(ref)
       end
 
-      private
+      # Drops a run's claim (or, with no run named, every claim); the bytes
+      # go when no claim is left.
+      def delete(ref, execution_namespace: nil)
+        enforce_tenant_isolation!
+        meta = @metadata[ref] if owns_ref?(ref)
+        return unless meta
 
-      def tag_execution_namespace(ref, execution_namespace)
-        return unless execution_namespace
+        execution_namespace ? meta[:claims].delete(execution_namespace) : meta[:claims].clear
+        return unless meta[:claims].empty?
 
-        namespaces = @metadata[ref][:execution_namespaces]
-        namespaces << execution_namespace unless namespaces.include?(execution_namespace)
+        @store.delete(ref)
+        @metadata.delete(ref)
+        nil
       end
 
-      def expired_match?(ref, meta, cutoff, execution_namespace)
-        owns_ref?(ref) &&
-          meta[:stored_at] < cutoff &&
-          (execution_namespace.nil? || meta[:execution_namespaces]&.include?(execution_namespace))
-      end
+      # Whether a run (its execution namespace) stored this ref.
+      def stored_by?(ref, execution_namespace)
+        return false if execution_namespace.nil? || !owns_ref?(ref)
 
-      def generate_ref(data)
-        content_hash = Digest::SHA256.hexdigest(data.to_s)
-        @namespace ? "#{@namespace}:#{content_hash}" : content_hash
+        @metadata.dig(ref, :claims)&.key?(execution_namespace) || false
       end
 
-      def owns_ref?(ref)
-        if @namespace
-          ref.start_with?("#{@namespace}:")
-        else
-          !ref.include?(":")
+      # Refs whose claims (or the run's claim, when one is named) are all
+      # older than the retention.
+      def expired(retention: nil, execution_namespace: nil)
+        retention = effective_retention(retention)
+        return [] unless retention
+
+        cutoff = Time.now.utc - retention
+        @metadata.filter_map do |ref, meta|
+          ref if owns_ref?(ref) && claims_before?(meta[:claims], execution_namespace, cutoff)
         end
       end
 
-      def enforce_tenant_isolation!
-        return unless Smith.config.artifact_tenant_isolation
+      private
 
-        raise Smith::Error, "artifact_tenant_isolation requires a namespace" unless @namespace
+      def claims_before?(claims, execution_namespace, cutoff)
+        claims = claims.slice(execution_namespace) if execution_namespace
+        !claims.empty? && claims.values.all? { |stored_at| stored_at < cutoff }
       end
     end
   end

data/lib/smith/artifacts/s3.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require_relative "store_rules"
+
+module Smith
+  module Artifacts
+    # An artifact store in an S3-compatible bucket: AWS S3, Cloudflare R2
+    # (`endpoint: "https://<account>.r2.cloudflarestorage.com"`,
+    # `region: "auto"`), MinIO and the like. Each artifact is one object
+    # under `prefix`, its ref a random UUID (after the store's tenant
+    # `namespace:` when one is set), and the run that stored it is kept in
+    # the object's metadata, so the store can say which run stored a ref.
+    #
+    # The client is the host's `Aws::S3::Client` (`client:`), or one built
+    # from the remaining options (`region:`, `endpoint:`,
+    # `access_key_id:`, `secret_access_key:`, ...), which needs the
+    # `aws-sdk-s3` gem in the host's bundle; Smith does not depend on it.
+    # Only keys of the store's ref shape under the prefix are artifacts, so
+    # other objects in the bucket are neither read, listed nor deleted.
+    class S3
+      include StoreRules
+
+      INNER_REF = StoreRules::UUID
+      NAMESPACE_KEY = "smith-execution-namespace"
+
+      def initialize(bucket:, prefix: "smith/artifacts", namespace: nil, client: nil, **client_options)
+        if client && client_options.any?
+          raise ArgumentError, "give Smith::Artifacts::S3 a client: or the options to build one, not both"
+        end
+
+        @bucket = bucket
+        @prefix = prefix.to_s.delete_suffix("/")
+        @namespace = check_namespace!(namespace)
+        @client = client || self.class.build_client(**client_options)
+      end
+
+      def self.build_client(**)
+        require "aws-sdk-s3"
+        ::Aws::S3::Client.new(**)
+      rescue LoadError
+        raise Smith::Error, "Smith::Artifacts::S3 needs the aws-sdk-s3 gem in the host's bundle, or a client:"
+      end
+
+      def store(data, content_type: "application/octet-stream", execution_namespace: nil)
+        enforce_tenant_isolation!
+        check_data!(data)
+        ref = generate_ref(SecureRandom.uuid)
+        metadata = execution_namespace ? { NAMESPACE_KEY => execution_namespace } : {}
+        @client.put_object(bucket: @bucket, key: object_key(ref), body: data, content_type:, metadata:)
+        ref
+      end
+
+      def fetch(ref)
+        enforce_tenant_isolation!
+        return unless owns_ref?(ref)
+
+        @client.get_object(bucket: @bucket, key: object_key(ref)).body.read
+      rescue StandardError => e
+        raise unless missing?(e)
+      end
+
+      # Whether a run (its execution namespace) stored this ref.
+      def stored_by?(ref, execution_namespace)
+        return false if execution_namespace.nil? || !owns_ref?(ref)
+
+        @client.head_object(bucket: @bucket, key: object_key(ref)).metadata[NAMESPACE_KEY] == execution_namespace
+      rescue StandardError => e
+        raise unless missing?(e)
+
+        false
+      end
+
+      # Listing the prefix, then (for one run's refs) a HEAD per expired
+      # object.
+      def expired(retention: nil, execution_namespace: nil)
+        retention = effective_retention(retention)
+        return [] unless retention
+
+        cutoff = Time.now.utc - retention
+        objects.filter_map do |object|
+          ref = object.key.delete_prefix(key_prefix)
+          next unless object.last_modified.utc < cutoff && owns_ref?(ref)
+          next if execution_namespace && !stored_by?(ref, execution_namespace)
+
+          ref
+        end
+      end
+
+      # Removes the artifact (when a run is named, only if that run stored
+      # it).
+      def delete(ref, execution_namespace: nil)
+        enforce_tenant_isolation!
+        return unless owns_ref?(ref) && (execution_namespace.nil? || stored_by?(ref, execution_namespace))
+
+        @client.delete_object(bucket: @bucket, key: object_key(ref))
+        nil
+      end
+
+      private
+
+      def key_prefix = @prefix.empty? ? "" : "#{@prefix}/"
+
+      def object_key(ref) = "#{key_prefix}#{ref}"
+
+      # Every object under the prefix, page by page.
+      def objects
+        Enumerator.new do |yielder|
+          token = nil
+          loop do
+            page = @client.list_objects_v2(bucket: @bucket, prefix: key_prefix, continuation_token: token)
+            page.contents.each { |object| yielder << object }
+            break unless page.is_truncated
+
+            token = page.next_continuation_token
+          end
+        end
+      end
+
+      # The SDK's missing-object errors (NoSuchKey on a read, NotFound on a
+      # head), by name, so Smith loads no SDK class.
+      def missing?(error) = error.class.name.to_s.end_with?("::NoSuchKey", "::NotFound")
+    end
+  end
+end