smith-agents 0.10.0 → 0.12.0

data/lib/smith/streaming/think_tags.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Smith
+  module Streaming
+    # Keeps a model's `<think>...</think>` text out of a stream. Some
+    # OpenAI-compatible reasoning models write their thinking into the reply
+    # between these tags, and RubyLLM moves it out of the message it
+    # accumulates; this does the same to the chunks as they come, a tag split
+    # across chunks included, so the stream holds the text the message will.
+    # Its state starts over with each provider request (`round`), as
+    # RubyLLM's accumulator does, and a partial tag left at a request's end
+    # is dropped, as there.
+    class ThinkTags
+      OPEN = "<think>"
+      CLOSE = "</think>"
+      private_constant :OPEN, :CLOSE
+
+      def initialize
+        @round = nil
+        start_over
+      end
+
+      # The part of `text` outside thinking (nil for anything but a String).
+      def strip(text, round)
+        start_over(round) unless round == @round
+        return unless text.is_a?(String)
+
+        remaining = @pending + text
+        @pending = +""
+        output = +""
+        remaining = consume(remaining, output) until remaining.empty?
+        output
+      end
+
+      private
+
+      def start_over(round = nil)
+        @round = round
+        @inside = false
+        @pending = +""
+      end
+
+      # Up to and past the next tag, or the rest, holding back a suffix that
+      # may begin the tag.
+      def consume(remaining, output)
+        tag = @inside ? CLOSE : OPEN
+        index = remaining.index(tag)
+        return hold(remaining, tag, output) unless index
+
+        output << remaining[0, index] unless @inside
+        @inside = !@inside
+        remaining[(index + tag.length)..]
+      end
+
+      def hold(remaining, tag, output)
+        held = held_back(remaining, tag)
+        output << remaining[0, remaining.length - held] unless @inside
+        @pending = remaining[remaining.length - held, held]
+        +""
+      end
+
+      def held_back(text, tag)
+        [text.length, tag.length - 1].min.downto(1).find { |length| text.end_with?(tag[0, length]) } || 0
+      end
+    end
+  end
+end

data/lib/smith/streaming.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "streaming/session"
+require_relative "streaming/think_tags"
+require_relative "streaming/json_field"
+
+module Smith
+  # A step declared with `execute Agent, stream: :name` sends its reply's
+  # text, as the model writes it, to a sink the host gives it. The host
+  # registers a callable under that name in `Smith.config.stream_sinks`;
+  # when the step starts, Smith calls it with the step's info (the stream's
+  # name, the run's execution key, the transition) and streams to the sink
+  # it returns, or does not stream the step when it returns nil (nobody is
+  # listening). Each step execution gets its own sink, so concurrent runs
+  # never share one.
+  #
+  # The sink is told of each provider call (`start(info)`), each text chunk
+  # (`delta(text)`), text Smith discards (`reset(reason)`), the step's
+  # accepted output once the step is stored (`finish(output)`) and its
+  # failure (`fail(error_class)`);
+  # Smith calls only the methods the sink defines. See Session. The text is
+  # the model's, before the step's guardrails and output checks run: a
+  # draft until `finish`.
+  #
+  # Streaming changes nothing durable: the step's output, usage, budgets,
+  # guardrails, contracts and persistence are those of the same step
+  # without it, and a replayed step streams again.
+  module Streaming
+    def self.check_sinks!(sinks)
+      raise ArgumentError, "Smith.config.stream_sinks must be a Hash of sink names to sinks" unless sinks.is_a?(Hash)
+
+      sinks.to_h { |name, sink| [checked_name!(name), checked_sink!(name, sink)] }.freeze
+    end
+
+    def self.checked_name!(name)
+      return name.to_sym if (name.is_a?(Symbol) || name.is_a?(String)) && !name.to_s.empty?
+
+      raise ArgumentError, "Smith.config.stream_sinks names must be Symbols or Strings, got #{name.inspect}"
+    end
+
+    def self.checked_sink!(name, sink)
+      return sink if sink.respond_to?(:call)
+
+      raise ArgumentError, "stream sink #{name.inspect} must be a callable that takes the step's info and returns " \
+                           "the step's sink (or nil)"
+    end
+    private_class_method :checked_name!, :checked_sink!
+
+    # The step's Session, or nil when its sink is nil (or the callable
+    # raised, which is logged). StreamSinkMissing when the name is not
+    # registered.
+    def self.open(name, execution_key:, transition:)
+      factory = Smith.config.stream_sinks.fetch(name) { raise StreamSinkMissing, name }
+      info = { stream: name, execution_key: execution_key&.dup&.freeze, transition: }.freeze
+      sink = begin
+        factory.call(info)
+      rescue StandardError, ScriptError => e
+        Smith.config.logger&.error("Smith stream sink #{name.inspect} call error: #{e.class}")
+        nil
+      end
+      sink && Session.new(sink, info)
+    end
+  end
+end

data/lib/smith/testing/checks.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Smith
+  module Testing
+    # The checks behind the assertions and matchers: each returns nil when
+    # it holds, else what failed.
+    module Checks
+      module_function
+
+      def waiting_for(workflow, event = nil, kind: nil)
+        wait = workflow.awaiting
+        return "expected the run to wait, but it is #{workflow.state} and not waiting" unless wait
+        return other_event(event, wait) if event && wait.event.to_s != event.to_s
+
+        "expected a #{kind} wait, but the run's is a #{wait.kind} wait" if kind && wait.kind.to_s != kind.to_s
+      end
+
+      def other_event(event, wait)
+        "expected the run to wait for #{event}, but it waits for #{wait.event || "a #{wait.kind}"}"
+      end
+
+      def transitioned_through(workflow, names)
+        taken = Testing.transitions(workflow)
+        rest = taken
+        names.each do |name|
+          index = rest.index(name.to_sym)
+          return "expected the run through #{names.inspect} in order; it went through #{taken.inspect}" unless index
+
+          rest = rest.drop(index + 1)
+        end
+        nil
+      end
+
+      def usage_recorded(workflow, count: nil, **attributes)
+        attributes = usage_attributes(attributes)
+        entries = workflow.usage_entries
+        found = entries.count { |entry| attributes.all? { |name, value| same?(entry.public_send(name), value) } }
+        return if count ? found == count : found.positive?
+
+        "expected #{count || "a"} usage entry matching #{attributes.inspect}, found #{found} among " \
+          "#{entries.map { _1.to_h.slice(:agent_name, :input_tokens, :output_tokens, :mode) }.inspect}"
+      end
+
+      # UsageEntry attributes; an agent class stands for its registered name.
+      def usage_attributes(attributes)
+        unknown = attributes.keys - Workflow::UsageEntry.members
+        raise ArgumentError, "unknown usage attributes: #{unknown.join(", ")}" unless unknown.empty?
+
+        agent = attributes[:agent_name]
+        agent.is_a?(Class) ? attributes.merge(agent_name: agent.register_as) : attributes
+      end
+
+      def same?(actual, expected)
+        actual == expected || ((expected.is_a?(Symbol) || expected.is_a?(String)) && actual.to_s == expected.to_s)
+      end
+    end
+  end
+end

data/lib/smith/testing/hooks.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Smith
+  module Testing
+    # An agent request Smith::Testing would not send: the agent has no stub
+    # and `Smith::Testing.unstubbed` is :refuse.
+    class UnstubbedCall < Smith::Error; end
+
+    # An agent's call bound to its provider object and chat, and its stub
+    # (nil for an agent with none, when unstubbed requests are refused).
+    Answering = Data.define(:stub, :provider, :chat, :agent) do
+      def reply(&)
+        return stub.reply(chat, &) if stub
+
+        raise UnstubbedCall, "#{agent || "an agent"} has no stub, and Smith::Testing.unstubbed is :refuse"
+      end
+    end
+
+    # A stubbed agent's call, bound to its provider object and chat, and
+    # the transitions a run completes (Workflow).
+    module Calls
+      private
+
+      def attempt_model(agent_class, ...)
+        with_testing_fiber(STUB, Testing.stub_for(agent_class)) { super }
+      end
+
+      def complete_chat(chat, model_reference, collected, facts = {})
+        stub = Fiber[STUB]
+        return super unless stub || Testing.unstubbed == :refuse
+
+        answering = Answering.new(stub:, provider: chat_provider(chat), chat:, agent: facts[:agent_name])
+        with_testing_fiber(ANSWERING, answering) { super }
+      end
+
+      def with_testing_fiber(key, value)
+        outer = Fiber[key]
+        Fiber[key] = value
+        yield
+      ensure
+        Fiber[key] = outer
+      end
+
+      # Every step a run counts passes here, on every path (a wait's
+      # completion and a prepared split-step's included); a failed or
+      # timed-out step is not a transition the run went through.
+      def record_step_snapshot(step_result)
+        if step_result.is_a?(Hash) && step_result[:transition] && !step_result[:error] && !step_result[:timed_out]
+          (@testing_transitions ||= []) << step_result[:transition].to_sym
+        end
+        super
+      end
+    end
+
+    # A stubbed call's requests, answered where they would go over the wire
+    # (RubyLLM::Provider, and Bedrock's own).
+    module Requests
+      private
+
+      def sync_response(...)
+        answering = Testing.answering(self)
+        answering ? answering.reply : super
+      end
+
+      def stream_response(*, **, &)
+        answering = Testing.answering(self)
+        answering ? answering.reply(&) : super
+      end
+    end
+
+    # The same for Smith's OpenAI Responses route, whose request is still
+    # rendered (as the chat route's is) before it is answered.
+    module ResponsesRequests
+      RENDERED = %i[tools temperature model schema thinking tool_prefs].freeze
+
+      def complete(provider, messages, **options, &)
+        answering = Testing.answering(provider)
+        return super unless answering
+
+        render_response_payload(messages, **options.slice(*RENDERED))
+        answering.reply(&)
+      end
+    end
+  end
+end

data/lib/smith/testing/minitest.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "smith/testing"
+
+module Smith
+  module Testing
+    # Minitest assertions for workflow runs (`include
+    # Smith::Testing::Assertions`); stubs are dropped after each test.
+    #
+    #   assert_waiting_for run, :approval
+    #   assert_waiting_for run, kind: :batch
+    #   assert_transitioned_through run, :triage, :draft
+    #   assert_usage_recorded run, agent_name: Triager, input_tokens: 40
+    #   assert_usage_recorded run, count: 2, mode: :batch
+    module Assertions
+      def assert_waiting_for(workflow, event = nil, kind: nil)
+        failure = Checks.waiting_for(workflow, event, kind:)
+        assert(failure.nil?, failure)
+      end
+
+      def assert_transitioned_through(workflow, *names)
+        failure = Checks.transitioned_through(workflow, names)
+        assert(failure.nil?, failure)
+      end
+
+      def assert_usage_recorded(workflow, count: nil, **attributes)
+        failure = Checks.usage_recorded(workflow, count:, **attributes)
+        assert(failure.nil?, failure)
+      end
+
+      def after_teardown
+        super
+        Testing.reset!
+      end
+    end
+  end
+end

data/lib/smith/testing/rspec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "smith/testing"
+
+module Smith
+  module Testing
+    # RSpec matchers for workflow runs, included in every example group;
+    # stubs are dropped after each example.
+    #
+    #   expect(run).to be_waiting_for(:approval)
+    #   expect(run).to be_waiting_for(kind: :batch)
+    #   expect(run).to have_transitioned_through(:triage, :draft)
+    #   expect(run).to have_recorded_usage(agent_name: Triager, input_tokens: 40)
+    module Matchers
+      # One of the Checks as a matcher.
+      class Matcher
+        attr_reader :description, :failure_message
+
+        def initialize(description, &check)
+          @description = description
+          @check = check
+        end
+
+        def matches?(workflow)
+          @failure_message = @check.call(workflow)
+          @failure_message.nil?
+        end
+
+        def failure_message_when_negated = "expected the run not to #{description}"
+      end
+
+      def be_waiting_for(event = nil, kind: nil)
+        Matcher.new("wait for #{event || kind || "anything"}") { Checks.waiting_for(_1, event, kind:) }
+      end
+
+      # rubocop:disable Naming/PredicatePrefix -- RSpec's have_ matcher names
+      def have_transitioned_through(*names)
+        Matcher.new("go through #{names.join(", ")}") { Checks.transitioned_through(_1, names) }
+      end
+
+      def have_recorded_usage(count: nil, **attributes)
+        Matcher.new("record usage #{attributes.inspect}") { Checks.usage_recorded(_1, count:, **attributes) }
+      end
+      # rubocop:enable Naming/PredicatePrefix
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Smith::Testing::Matchers
+  config.after { Smith::Testing.reset! }
+end

data/lib/smith/testing/stub.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Smith
+  module Testing
+    # A tool request among a stub's outputs: the tool's name as the model
+    # sees it, and its arguments.
+    ToolRequest = Data.define(:name, :arguments)
+
+    # An agent's stubbed replies, and the messages each request sent.
+    class Stub
+      TOKENS = %i[input_tokens output_tokens cached_tokens cache_creation_tokens thinking_tokens].freeze
+      DEFAULT_USAGE = { input_tokens: 10, output_tokens: 5 }.freeze
+      OUTPUTS = "a stubbed output is a String, a Hash, or a tool_call (or an Array of them)"
+
+      # ArgumentError unless the stub can answer.
+      def self.check!(outputs, usage, stop_reason, stream)
+        raise ArgumentError, "stub_agent needs at least one output" if outputs.empty?
+        raise ArgumentError, OUTPUTS unless outputs.all? { output?(_1) }
+        raise ArgumentError, "a stub's usage is token counts by #{TOKENS.join(", ")}" unless usage?(usage)
+        raise ArgumentError, "a stub's stop_reason is a String" unless stop_reason.is_a?(String)
+        raise ArgumentError, "a stub's stream is a piece size" unless stream.nil? || count?(stream, positive: true)
+      end
+
+      def self.output?(output)
+        [String, Hash, ToolRequest].any? { output.is_a?(_1) } || tool_requests?(output)
+      end
+
+      def self.tool_requests?(output) = output.is_a?(Array) && !output.empty? && output.all?(ToolRequest)
+
+      def self.usage?(usage) = usage.is_a?(Hash) && (usage.keys - TOKENS).empty? && usage.values.all? { count?(_1) }
+
+      def self.count?(value, positive: false) = value.is_a?(Integer) && (positive ? value.positive? : !value.negative?)
+
+      def initialize(outputs:, usage:, stop_reason:, stream:)
+        @outputs = outputs.map { self.class.output_entry(_1) }.freeze
+        @usage = DEFAULT_USAGE.merge(usage).freeze
+        @stop_reason = stop_reason
+        @stream = stream
+        @calls = []
+        @lock = Mutex.new
+      end
+
+      # An output as the stub keeps it: a String, or the tool requests of
+      # one round.
+      def self.output_entry(output)
+        return output if output.is_a?(String)
+        return Array(output).freeze if output.is_a?(ToolRequest) || tool_requests?(output)
+
+        JSON.generate(output)
+      end
+
+      # The messages each request sent, in request order.
+      def calls = @lock.synchronize { @calls.dup }
+
+      # The reply to the next request of `chat`; a streamed one's text is
+      # yielded as chunks first.
+      def reply(chat)
+        output, index = take(chat.messages)
+        message = output.is_a?(String) ? text(output, chat, index) : tools(output, chat, index)
+        pieces(message.content).each { yield chunk(_1, message) } if block_given?
+        message
+      end
+
+      private
+
+      def take(messages)
+        @lock.synchronize do
+          @calls << messages.dup.freeze
+          [@outputs[[@calls.length, @outputs.length].min - 1], @calls.length]
+        end
+      end
+
+      def text(content, chat, index) = reply_message(chat, index, @stop_reason, content:)
+
+      # A request for tools the chat has (RubyLLM would tell the model a
+      # tool it lacks is missing, and go on).
+      def tools(requests, chat, index)
+        check_tools!(requests, chat.tools.keys.map(&:to_s))
+        calls = requests.each_with_index.to_h do |request, position|
+          id = "toolu_stub_#{index}_#{position + 1}"
+          [id, RubyLLM::ToolCall.new(id:, name: request.name, arguments: request.arguments)]
+        end
+        reply_message(chat, index, "tool_use", content: "", tool_calls: calls)
+      end
+
+      def check_tools!(requests, known)
+        unknown = requests.map(&:name).find { !known.include?(_1) }
+        return unless unknown
+
+        has = known.empty? ? "it has none" : "it has #{known.join(", ")}"
+        raise ArgumentError, "a stubbed tool request names #{unknown}, a tool the agent does not have (#{has})"
+      end
+
+      def reply_message(chat, index, stop_reason, **parts)
+        RubyLLM::Message.new(role: :assistant, model_id: chat.model.id, **parts, **@usage,
+                             raw: Providers::ResponseFacts.kept(stop_reason:, id: "msg_stub_#{index}"))
+      end
+
+      def chunk(text, message) = RubyLLM::Chunk.new(role: :assistant, content: text, model_id: message.model_id)
+
+      def pieces(text)
+        return [] if text.to_s.empty?
+
+        @stream ? text.each_char.each_slice(@stream).map(&:join) : [text]
+      end
+    end
+  end
+end

data/lib/smith/testing.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "json"
+require "smith"
+require_relative "testing/stub"
+require_relative "testing/checks"
+require_relative "testing/hooks"
+
+module Smith
+  # Testing a host's workflows without a provider (`require "smith/testing"`).
+  #
+  #   Smith::Testing.stub_agent(Summarizer, outputs: [Smith::Testing.tool_call(Lookup, id: 7),
+  #                                                   "A short summary."],
+  #                                         usage: { input_tokens: 40, output_tokens: 8 })
+  #   run = Review.new(context: {})
+  #   Smith::Testing.run_until_waiting(run)
+  #   Smith::Testing.resume_with(run, payload: { approved: true })
+  #
+  # A stubbed agent's requests are answered where they would go over the
+  # wire, so everything above runs as for a provider's reply: the tool loop,
+  # budget holds, the response memo, streaming, output checks and repairs,
+  # usage entries and budgets. Each request takes the next of its outputs
+  # (the last answers every request after it): a String reply, a Hash as
+  # JSON text (for an agent with an output schema), or a tool request
+  # (`tool_call`, or an Array of them), which runs the agent's own tools
+  # before its next request. Replies carry the stub's usage and stop
+  # reason; a streamed one reaches its sink in pieces of `stream:`
+  # characters. A batch step's request is captured as ever (the batch
+  # queue gets it), and its delivery (`batch_payload`) answers it.
+  #
+  # Only the agent's own requests are answered: a tool's own provider call
+  # is not. An agent with no stub goes over the wire, unless `unstubbed =
+  # :refuse` fails its call first. Stubs are the process's: `reset!` drops them (smith/testing/
+  # minitest and smith/testing/rspec do after each test). The chat is still
+  # built, so the agent's provider must be configured (any key).
+  # Smith::Testing::Checks are what the Minitest assertions and RSpec
+  # matchers check.
+  module Testing
+    STUB = :smith_testing_stub
+    ANSWERING = :smith_testing_answering
+    private_constant :STUB, :ANSWERING
+
+    UNSTUBBED = %i[send refuse].freeze
+
+    @stubs = {}
+    @stubs_lock = Mutex.new
+    @unstubbed = :send
+
+    module_function
+
+    # What an agent request without a stub does: :send (the default) sends
+    # it over the wire; :refuse fails its call with UnstubbedCall before
+    # anything is sent (a mistyped stub then cannot reach a paid provider).
+    def unstubbed = @unstubbed
+
+    def unstubbed=(mode)
+      raise ArgumentError, "Smith::Testing.unstubbed is :send or :refuse" unless UNSTUBBED.include?(mode)
+
+      @unstubbed = mode
+    end
+
+    # Answers `agent`'s requests (its class, or its registered name) with
+    # `outputs`; returns the Stub.
+    def stub_agent(agent, outputs:, usage: {}, stop_reason: "end_turn", stream: nil)
+      outputs = [outputs] unless outputs.is_a?(Array)
+      Stub.check!(outputs, usage, stop_reason, stream)
+      stub = Stub.new(outputs:, usage:, stop_reason:, stream:)
+      @stubs_lock.synchronize { @stubs[agent.is_a?(Module) ? agent : agent.to_sym] = stub }
+    end
+
+    # A tool request, as a stub's output: the model asks for `tool` (its
+    # class, or its name as the model sees it) with `arguments`.
+    def tool_call(tool, **arguments)
+      name = tool.is_a?(Class) ? tool.allocate.name : tool.to_s
+      ToolRequest.new(name:, arguments: JSON.parse(JSON.generate(arguments)))
+    end
+
+    # The stub for `agent_class`, by class or registered name.
+    def stub_for(agent_class)
+      @stubs_lock.synchronize { @stubs[agent_class] || @stubs[agent_class.register_as&.to_sym] }
+    end
+
+    def reset! = @stubs_lock.synchronize { @stubs.clear }
+
+    # The stubbed call that answers `provider`'s request now, or nil: only
+    # the call's own provider object, and never a batch capture or delivery
+    # (Providers::BatchExchange answers those).
+    def answering(provider)
+      answering = Fiber[ANSWERING]
+      answering if answering&.provider.equal?(provider) && !Providers::BatchExchange.exchange_for(provider)
+    end
+
+    # The transitions the workflow instance completed, in order.
+    def transitions(workflow) = (workflow.instance_variable_get(:@testing_transitions) || []).dup
+
+    # Runs the workflow until it waits or ends; returns its wait, or nil. A
+    # durable retry's backoff is ended at once unless `retries: false`.
+    def run_until_waiting(workflow, retries: true)
+      loop do
+        workflow.run!
+        wait = workflow.awaiting
+        return wait unless retries && wait&.kind == :retry
+
+        workflow.expire_wait!(token: wait.token, now: wait.deadline_at + 1)
+      end
+    end
+
+    # Delivers `payload` to the workflow's wait (its event, unless `event`)
+    # and runs it on until it waits or ends; returns what `resume!` did.
+    def resume_with(workflow, payload: nil, event: nil)
+      wait = waiting!(workflow)
+      outcome = workflow.resume!(event: event || wait.event, token: wait.token, payload:)
+      run_until_waiting(workflow) unless outcome == :stale
+      outcome
+    end
+
+    # Ends the workflow's wait as if its deadline had passed and runs it on;
+    # returns what `expire_wait!` did.
+    def expire(workflow)
+      wait = waiting!(workflow)
+      outcome = workflow.expire_wait!(token: wait.token, now: wait.deadline_at + 1)
+      run_until_waiting(workflow) if outcome == :expired
+      outcome
+    end
+
+    def waiting!(workflow) = workflow.awaiting || raise(ArgumentError, "the run is not waiting")
+    private_class_method :waiting!
+
+    # A batch result as the provider's results file gives it: a succeeded
+    # one with `output` (a String, or a Hash as JSON) as its reply, or
+    # `type: "errored"`, "canceled" or "expired".
+    def batch_result(output = "", type: "succeeded", usage: {}, stop_reason: "end_turn")
+      return { "type" => type } unless type == "succeeded"
+
+      text = output.is_a?(String) ? output : JSON.generate(output)
+      tokens = { "input_tokens" => usage.fetch(:input_tokens, 10), "output_tokens" => usage.fetch(:output_tokens, 5) }
+      { "type" => "succeeded",
+        "message" => { "id" => "msg_batch", "type" => "message", "role" => "assistant",
+                       "content" => [{ "type" => "text", "text" => text }], "stop_reason" => stop_reason,
+                       "usage" => tokens } }
+    end
+
+    # The delivery for a waiting batch step: `results` is one result for an
+    # agent step, or a fan-out's results by branch key.
+    def batch_payload(workflow, results)
+      token = waiting!(workflow).token
+      results = JSON.parse(JSON.generate(results))
+      return { token => results } if results.key?("type")
+
+      results.to_h { |branch_key, result| [Batch.custom_id(token, branch_key), result] }
+    end
+  end
+end
+
+Smith::Workflow.prepend(Smith::Testing::Calls)
+RubyLLM::Provider.prepend(Smith::Testing::Requests)
+RubyLLM::Providers::Bedrock.prepend(Smith::Testing::Requests)
+Smith::Providers::OpenAI::Responses.singleton_class.prepend(Smith::Testing::ResponsesRequests)

data/lib/smith/tool/scoped_context.rb

@@ -16,7 +16,8 @@ module Smith
         current_invocation_batch_admitter: :smith_tool_invocation_batch_admitter,
         current_invocation_failure_handler: :smith_tool_invocation_failure_handler,
         current_invocation_sequence: :smith_tool_invocation_sequence,
-        current_invocation: :smith_tool_invocation
+        current_invocation: :smith_tool_invocation,
+        current_idempotency_scope: :smith_idempotency_scope
       }.freeze
 
       CONTEXT_KEYS.each do |reader, key|
@@ -24,17 +25,13 @@ module Smith
         define_method("#{reader}=") { |value| Thread.current[key] = value }
       end
 
-      private :current_invocation_batch_admitter,
-              :current_invocation_batch_admitter=,
-              :current_invocation_failure_handler,
-              :current_invocation_failure_handler=,
-              :current_invocation_sequence,
-              :current_invocation_sequence=,
-              :current_tool_dispatch_claim,
-              :current_tool_dispatch_claim=,
-              :current_tool_dispatch_start_handler,
-              :current_tool_dispatch_start_handler=,
-              :current_invocation=
+      private :current_invocation_batch_admitter, :current_invocation_batch_admitter=,
+              :current_invocation_failure_handler, :current_invocation_failure_handler=,
+              :current_invocation_sequence, :current_invocation_sequence=,
+              :current_tool_dispatch_claim, :current_tool_dispatch_claim=,
+              :current_tool_dispatch_start_handler, :current_tool_dispatch_start_handler=,
+              :current_invocation=,
+              :current_idempotency_scope, :current_idempotency_scope=
 
       def self.capture
         CONTEXT_KEYS.to_h { |reader, key| [reader, Thread.current[key]] }.freeze