squishling 0.1.0 → 0.2.0

data/lib/squishling/configuration.rb

@@ -2,12 +2,20 @@
 
 module Squishling
   class Configuration
-    # Model used by every squishling class that doesn't declare its own.
-    # When nil, RubyLLM's own default model is used.
-    attr_accessor :default_model
+    # Model used by every squishling class that doesn't declare its own (a single attempt).
+    # When neither this nor default_escalation is set, RubyLLM's own default model is used.
+    attr_reader :default_model
 
-    # Provider for default_model (e.g. :openai). Only needed for models missing from
-    # RubyLLM's registry.
+    # Models tried in order by every squishling class that doesn't declare its own, e.g.
+    #   [{ model: "claude-haiku-4-5", attempts: 2 }, "claude-sonnet-5-5", "claude-opus-5-5"]
+    # See ModelPath. default_model and default_escalation set the same thing: assigning one clears the other.
+    attr_reader :default_escalation
+
+    # The validated default_model or default_escalation steps (nil when neither is set).
+    attr_reader :default_model_path
+
+    # Provider for default_model/default_escalation steps that don't name their own (e.g. :openai). Only
+    # needed for models missing from RubyLLM's registry.
     attr_accessor :default_provider
 
     # Generation params applied to every call, overridable per class and per method.
@@ -15,22 +23,44 @@ module Squishling
     # with_thinking; any other key (top_p, max_tokens, seed, ...) is passed to the provider as-is.
     attr_reader :default_params
 
-    # How many times to re-ask the LLM when its output fails schema validation.
-    attr_accessor :max_retries
-
-    # Optional Logger for routing decisions.
+    # Optional Logger for routing and escalation decisions.
     attr_accessor :logger
 
     def initialize
       @default_model = nil
+      @default_escalation = nil
+      @default_model_path = nil
       @default_provider = nil
       @default_params = {}
-      @max_retries = 1
       @logger = nil
     end
 
+    def default_model=(model)
+      @default_model_path = ModelPath.from_model(model, "default_model")
+      @default_escalation = nil
+      @default_model = model
+    end
+
+    def default_escalation=(escalation)
+      @default_model_path = ModelPath.from_escalation(escalation, "default_escalation")
+      @default_model = nil
+      @default_escalation = escalation
+    end
+
     def default_params=(params)
       @default_params = Params.normalize(params, "default_params")
     end
+
+    MAX_RETRIES_REMOVED = "max_retries was removed; use default_escalation (or a class/method escalation:) " \
+                          "with attempts:, e.g. [{ model: \"claude-haiku-4-5\", attempts: 2 }]"
+
+    # Removed: the escalation decides how many attempts run.
+    def max_retries
+      raise ConfigurationError, MAX_RETRIES_REMOVED
+    end
+
+    def max_retries=(_value)
+      raise ConfigurationError, MAX_RETRIES_REMOVED
+    end
   end
 end

data/lib/squishling/definition.rb

@@ -10,7 +10,7 @@ module Squishling
     attr_reader :klass, :name, :call_context
 
     def initialize(klass:, name:, instructions: nil, append_instructions: nil, output_schema: nil, model: nil,
-      provider: nil, params: nil, predicate: nil, fallback: nil, call_context: {})
+      provider: nil, params: nil, predicate: nil, fallback: nil, validator: nil, call_context: {})
       @klass = klass
       @name = name
       @instructions = instructions
@@ -21,13 +21,16 @@ module Squishling
       @params = params
       @predicate = predicate
       @fallback = fallback
+      @validator = validator
       @call_context = call_context
     end
 
-    # This definition with one call's overrides on top. The output schema and predicate can't be overridden:
-    # the call must still return the method's result type.
-    def for_call(instructions: nil, append_instructions: nil, context: nil, model: nil, provider: nil, params: nil)
-      raise ConfigurationError, "#{label}: squish! provider: needs a model:" if provider && !model
+    # This definition with one call's overrides on top. The output schema, predicate, fallback, and validator
+    # can't be overridden: the call must still return the method's result type.
+    def for_call(instructions: nil, append_instructions: nil, context: nil, model: nil, escalation: nil,
+      provider: nil, params: nil)
+      call_path = ModelPath.declare(model, escalation, "#{label} squish!")
+      raise ConfigurationError, "#{label}: squish! provider: needs a model: or escalation:" if provider && !call_path
       unless context.nil? || (context.is_a?(Hash) && context.each_key.all?(NAME_KEY))
         raise ConfigurationError, "#{label}: squish! context: must be a Hash with String or Symbol keys"
       end
@@ -36,9 +39,10 @@ module Squishling
       call_params = params && Params.normalize(params, "#{label} squish! params")
       self.class.new(
         klass:, name:, output_schema: @output_schema, predicate: @predicate, fallback: @fallback,
+        validator: @validator,
         instructions: instructions || @instructions,
         append_instructions: [*@append_instructions, *appended],
-        model: model || @model, provider: model ? provider : @provider,
+        model: call_path || @model, provider: call_path ? provider : @provider,
         # merge, not Params.resolve: a nil at the method level must still unset the class's key.
         params: call_params ? (@params || {}).merge(call_params) : @params,
         call_context: @call_context.merge((context || {}).transform_keys(&:to_sym))
@@ -67,20 +71,15 @@ module Squishling
       raw && Schema.for(raw)
     end
 
-    def model
-      model_and_provider.first
-    end
-
-    def provider
-      model_and_provider.last
-    end
-
-    # A provider travels with the model declared at the same level (method, class, or config),
-    # so a per-method Anthropic model never inherits a class-level OpenAI provider.
-    def model_and_provider
+    # One ModelPath::Step per attempt, from the first level (method, class, or config) that declares a model
+    # or escalation, or a single attempt on RubyLLM's default model. A provider travels with the model declared
+    # at the same level, so a per-method Anthropic model never inherits a class-level OpenAI provider.
+    def escalation_path
       config = Squishling.config
-      [[@model, @provider], [klass.squishling_model, klass.squishling_provider],
-       [config.default_model, config.default_provider]].find(&:first) || [nil, nil]
+      entries, provider = [[@model, @provider], [klass.squishling_model_path, klass.squishling_provider],
+                           [config.default_model_path, config.default_provider]].find(&:first)
+      entries ||= [{ model: nil, attempts: 1 }]
+      ModelPath.steps(entries, provider:, params:)
     end
 
     # Generation params: config defaults, overridden key by key by the class, then by the method.
@@ -88,6 +87,11 @@ module Squishling
       Params.resolve(Squishling.config.default_params, klass.squishling_params, @params)
     end
 
+    # Extra output checks run on schema-valid LLM results (see ClassMethods#squish_validate).
+    def validator
+      @validator || klass.squishling_validator
+    end
+
     def context_names
       klass.squishling_context_names
     end
@@ -128,20 +132,30 @@ module Squishling
       schema.build(data, squished:)
     end
 
-    # Map positional and keyword arguments onto the original method's parameter names.
+    # Map positional and keyword arguments onto the original method's parameter names. A positional with no
+    # name (a destructuring parameter, or one beyond the declared parameters) is sent as arg0, arg1, ...
     def bind_arguments(args, kwargs)
       positional = args.dup
       bound = {}
+      unnamed = 0
 
       parameters.each do |type, param|
         case type
         when :req, :opt
-          bound[param] = positional.shift unless positional.empty? || param.nil?
+          next if positional.empty?
+
+          value = positional.shift
+          if param
+            bound[param] = value
+          else
+            bound[:"arg#{unnamed}"] = value
+            unnamed += 1
+          end
         when :rest
           bound[param.nil? || param == :* ? :args : param] = positional.shift(positional.size)
         end
       end
-      positional.each_with_index { |value, index| bound[:"arg#{index}"] = value }
+      positional.each_with_index { |value, index| bound[:"arg#{unnamed + index}"] = value }
 
       bound.merge(kwargs)
     end

data/lib/squishling/errors.rb

@@ -7,16 +7,19 @@ module Squishling
   # missing API key). Never retried and never passed to squish_fallback.
   class ConfigurationError < Error; end
 
-  # Output that didn't match the schema: from the LLM after all retries, or from the deterministic path.
+  # Output that didn't match the schema (or a squish_validate check): from the LLM after every attempt in the
+  # escalation, or from the deterministic path.
   class InvalidOutputError < Error
-    attr_reader :errors, :raw, :attempts
+    # models: the model ids tried, one per attempt (nil entries mean RubyLLM's default model).
+    attr_reader :errors, :raw, :attempts, :models
 
-    def initialize(errors:, raw: nil, source: "LLM", attempts: nil)
+    def initialize(errors:, raw: nil, source: "LLM", attempts: nil, models: nil)
       @errors = errors
       @raw = raw
       @attempts = attempts
+      @models = models
       tries = attempts ? " after #{attempts} attempt#{'s' unless attempts == 1}" : ""
-      super("#{source} output did not match the output schema#{tries}: #{errors.join('; ')}")
+      super("#{source} output was invalid#{tries}: #{errors.join('; ')}")
     end
   end
 

data/lib/squishling/invoker.rb

@@ -14,68 +14,97 @@ module Squishling
       @inputs = inputs
     end
 
+    # Makes each attempt of the escalation (Definition#escalation_path) until an output passes the schema and
+    # the squish_validate check. Consecutive attempts on the same step continue the same conversation, so the
+    # model sees what it got wrong; a new step starts a fresh chat told about the last rejected output.
     def call
-      instructions = @definition.instructions(@receiver)
-      schema = @definition.schema
-      raise ConfigurationError, "#{@definition.label} has no instructions" if instructions.nil? || instructions.empty?
-      raise ConfigurationError, "#{@definition.label} has no output_schema" unless schema
-
-      chat = build_chat
-      chat.with_instructions("#{instructions}\n\n#{INPUT_NOTE}")
-      chat.with_schema(schema.llm_schema)
-      apply_params(chat)
-
-      response = ask(chat, JSON.generate(payload))
-      attempts = 0
-      loop do
-        attempts += 1
-        data, errors = parse(response.content)
-        errors = schema.validate(data) if errors.empty?
-        return schema.build(data, squished: true) if errors.empty?
-
-        if attempts > Squishling.config.max_retries
-          raise InvalidOutputError.new(errors:, raw: response.content, attempts:)
+      @instructions = @definition.instructions(@receiver)
+      @schema = @definition.schema
+      raise ConfigurationError, "#{@definition.label} has no instructions" if @instructions.nil? || @instructions.empty?
+      raise ConfigurationError, "#{@definition.label} has no output_schema" unless @schema
+
+      path = @definition.escalation_path
+      input = JSON.generate(payload)
+      chat = nil
+      rejected = nil # [raw content, errors] of the last invalid output
+      models = []
+
+      path.each.with_index(1) do |step, attempt|
+        models << step.model
+        last = attempt == path.size
+        if chat && step == path[attempt - 2]
+          message = retry_message(rejected.last)
+        else
+          chat = start_chat(step)
+          message = rejected ? escalation_message(input, *rejected) : input
         end
 
-        response = ask(chat, retry_message(errors))
+        begin
+          response = ask(chat, message, step)
+        rescue LLMError => e
+          raise if last
+
+          # The failed request may be half-recorded in this chat, so the next attempt starts a fresh one.
+          chat = nil
+          log_failure(attempt, path, e.message)
+          next
+        end
+
+        result, errors = check(response.content)
+        return result if errors.empty?
+
+        raise InvalidOutputError.new(errors:, raw: response.content, attempts: attempt, models:) if last
+
+        rejected = [response.content, errors]
+        log_failure(attempt, path, errors.join("; "))
       end
     end
 
     private
 
-    def build_chat
-      RubyLLM.chat(**chat_options)
+    def start_chat(step)
+      chat = build_chat(step)
+      chat.with_instructions("#{@instructions}\n\n#{INPUT_NOTE}")
+      chat.with_schema(@schema.llm_schema)
+      apply_params(chat, step.params)
+      chat
+    end
+
+    def build_chat(step)
+      RubyLLM.chat(**chat_options(step))
     rescue RubyLLM::ModelNotFoundError, RubyLLM::ConfigurationError => e
       raise ConfigurationError, "#{@definition.label}: #{e.message}"
     end
 
     # RubyLLM validates some settings locally (e.g. an impossible thinking budget for the model)
     # and raises ArgumentError before any request is sent.
-    def apply_params(chat)
-      Params.apply(chat, @definition.params)
+    def apply_params(chat, params)
+      Params.apply(chat, params)
     rescue ArgumentError => e
-      raise ConfigurationError, "#{@definition.label}: invalid params #{@definition.params.inspect} (#{e.message})"
+      raise ConfigurationError, "#{@definition.label}: invalid params #{params.inspect} (#{e.message})"
     end
 
-    # Transient HTTP failures are already retried by RubyLLM (config.max_retries); anything that
-    # still fails is surfaced as an LLMError rather than retried again here. A 400 means the request
-    # we built is invalid (an unsupported param, a schema the provider rejects), so it's a setup
-    # mistake: a fallback would otherwise hide it on every call.
-    def ask(chat, message)
+    # Transient HTTP failures are already retried by RubyLLM (RubyLLM.config.max_retries); anything
+    # that still fails is surfaced as an LLMError, which moves on to the next attempt of the
+    # escalation (or propagates from the last one). A 400 means the request we built is invalid (an
+    # unsupported param, a schema the provider rejects), so it's a setup mistake: escalating or a
+    # fallback would otherwise hide it on every call.
+    def ask(chat, message, step)
       chat.ask(message)
     rescue RubyLLM::ConfigurationError, RubyLLM::UnauthorizedError, RubyLLM::ForbiddenError => e
       raise ConfigurationError, "#{@definition.label}: #{e.class}: #{e.message}"
     rescue RubyLLM::BadRequestError => e
-      raise ConfigurationError, "#{@definition.label}: the provider rejected the request (#{e.message})#{params_hint}"
+      raise ConfigurationError,
+        "#{@definition.label}: the provider rejected the request (#{e.message})#{params_hint(step.params)}"
     rescue RubyLLM::Error, Faraday::Error => e
       raise LLMError, "#{@definition.label}: #{e.class}: #{e.message}"
     end
 
     # Models missing from RubyLLM's registry (e.g. newly released ones) are only usable when a
     # provider is named, so RubyLLM is told to assume they exist.
-    def chat_options
-      model = @definition.model
-      provider = @definition.provider
+    def chat_options(step)
+      model = step.model
+      provider = step.provider
       options = { model:, provider: }.compact
       options[:assume_model_exists] = true if model && provider && !known_model?(model, provider)
       options
@@ -88,8 +117,7 @@ module Squishling
       false
     end
 
-    def params_hint
-      params = @definition.params
+    def params_hint(params)
       return "" if params.empty?
 
       ". Check params #{params.inspect}; reasoning models often reject sampling params such as temperature and top_p"
@@ -143,9 +171,75 @@ module Squishling
       text[/\A\s*```(?:json)?\s*\n(.*?)\n\s*```\s*\z/m, 1] || text
     end
 
+    # Parses and validates a response: [typed result, []] when it passes, [nil or result, errors] otherwise.
+    def check(content)
+      data, errors = parse(content)
+      errors = @schema.validate(data) if errors.empty?
+      return [nil, errors] if errors.any?
+
+      result = @schema.build(data, squished: true)
+      [result, validator_errors(result)]
+    end
+
+    # Runs the squish_validate check, if any. Exceptions it raises are the user's own and propagate as-is.
+    def validator_errors(result)
+      validator = @definition.validator
+      return [] unless validator
+
+      value = @receiver.instance_exec(result, **@inputs, &validator)
+      case value
+      when nil, true then []
+      when false then ["the output was rejected by squish_validate"]
+      when String, Array then Array(value).flatten.compact.map(&:to_s).reject { |message| message.strip.empty? }
+      else
+        return contract_errors(value) if value.respond_to?(:success?) && value.respond_to?(:errors)
+
+        raise ConfigurationError, "#{@definition.label}: squish_validate must return nil, true, false, a String, " \
+                                  "an Array of Strings, or a validation result, got #{value.class}"
+      end
+    end
+
+    # A dry-validation style result: errors.to_h is { key => ["message", ...] }, nested for nested keys.
+    def contract_errors(value)
+      return [] if value.success?
+
+      errors = value.errors
+      errors = errors.to_h if !errors.is_a?(Array) && errors.respond_to?(:to_h)
+      messages = errors.is_a?(Hash) ? flatten_messages(errors) : Array(errors).map(&:to_s)
+      messages.empty? ? ["the output was rejected by squish_validate"] : messages
+    end
+
+    def flatten_messages(errors, prefix = nil)
+      errors.flat_map do |key, value|
+        path = [prefix, key].compact.join(".")
+        next flatten_messages(value, path) if value.is_a?(Hash)
+
+        Array(value).map { |message| path.empty? ? message.to_s : "#{path} #{message}" }
+      end
+    end
+
     def retry_message(errors)
-      "Your previous response did not match the required schema:\n- #{errors.join("\n- ")}\n" \
-        "Respond again with corrected JSON only."
+      "Your previous response was rejected:\n- #{errors.join("\n- ")}\nRespond again with corrected JSON only."
+    end
+
+    # The first message to a fresh chat after an earlier model's output was rejected.
+    def escalation_message(input, raw, errors)
+      previous = raw.is_a?(String) ? raw : JSON.generate(raw)
+      previous = "(an empty response)" if previous.strip.empty? || raw.nil?
+      "#{input}\n\nA previous attempt at this request returned:\n#{previous}\n" \
+        "It was rejected:\n- #{errors.join("\n- ")}\nRespond with corrected JSON only."
+    end
+
+    def log_failure(attempt, path, reason)
+      step = path[attempt - 1]
+      next_step = path[attempt]
+      action = next_step == step ? "retrying" : "escalating to #{model_name(next_step)}"
+      Squishling.config.logger&.warn("[Squishling] #{@definition.label} attempt #{attempt} of #{path.size} " \
+                                     "(#{model_name(step)}) failed, #{action}: #{reason}")
+    end
+
+    def model_name(step)
+      step.model || "RubyLLM default model"
     end
   end
 end

data/lib/squishling/model_path.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Squishling
+  # The models a squished call tries, in order. Declared either as one model (model: "claude-haiku-4-5", a
+  # single attempt) or as an escalation: an Array of steps, each a model name or a Hash:
+  #   escalation: [
+  #     { model: "claude-haiku-4-5", attempts: 2 },
+  #     "claude-sonnet-5-5",
+  #     { model: "claude-opus-5-5", params: { thinking: { effort: :high } } }
+  #   ]
+  # attempts: (default 1) retries a step; order: (all steps or none, unique, lowest first) makes the order
+  # explicit instead of positional.
+  module ModelPath
+    # One attempt: the model, its provider, and the fully resolved generation params.
+    Step = Data.define(:model, :provider, :params)
+
+    STEP_KEYS = %i[model provider params attempts order].freeze
+
+    module_function
+
+    # A single model: model:/default_model. Returns a one-step path, or nil when not declared.
+    def from_model(model, label)
+      return nil if model.nil?
+
+      if model.is_a?(Array) || model.is_a?(Hash)
+        raise ConfigurationError, "#{label} takes one model; use escalation: [...] to try several in order"
+      end
+
+      [normalize_step(model, label)].freeze
+    end
+
+    # An escalation: escalation:/default_escalation. Returns the steps in order, or nil when not declared.
+    def from_escalation(escalation, label)
+      return nil if escalation.nil?
+      unless escalation.is_a?(Array)
+        raise ConfigurationError, "#{label} must be an Array of steps, got #{escalation.class}"
+      end
+      raise ConfigurationError, "#{label} can't be empty" if escalation.empty?
+
+      ordered(escalation.map { |step| normalize_step(step, label) }, label).freeze
+    end
+
+    # model: and escalation: both describe what to try, so a level may declare only one of them.
+    def declare(model, escalation, label)
+      if !model.nil? && !escalation.nil?
+        raise ConfigurationError, "#{label}: declare model: or escalation:, not both (put the model in the escalation)"
+      end
+
+      from_model(model, "#{label} model") || from_escalation(escalation, "#{label} escalation")
+    end
+
+    # One Step per attempt. The level's provider applies to steps that don't name their own, and each
+    # step's params are merged over the level-resolved params.
+    def steps(path, provider:, params:)
+      path.flat_map do |step|
+        attempt = Step.new(model: step[:model], provider: step[:provider] || provider,
+          params: Params.resolve(params, step[:params]))
+        [attempt] * step[:attempts]
+      end
+    end
+
+    def ordered(steps, label)
+      numbered = steps.count { |step| step.key?(:order) }
+      return steps.map { |step| step.except(:order) } if numbered.zero?
+
+      if numbered < steps.size
+        raise ConfigurationError, "#{label}: give every step an order: or none (#{numbered} of #{steps.size} have one)"
+      end
+
+      orders = steps.map { |step| step[:order] }
+      duplicates = orders.tally.select { |_, count| count > 1 }.keys
+      raise ConfigurationError, "#{label}: duplicate order: #{duplicates.join(', ')}" if duplicates.any?
+
+      steps.sort_by { |step| step[:order] }.map { |step| step.except(:order) }
+    end
+
+    def normalize_step(step, label)
+      case step
+      when String, Symbol then { model: model_name(step, label), provider: nil, params: nil, attempts: 1 }
+      when Hash then normalize_hash(step, label)
+      else
+        raise ConfigurationError, "#{label}: each step must be a model name or a Hash with model:, got #{step.inspect}"
+      end
+    end
+
+    def normalize_hash(step, label)
+      step = step.transform_keys(&:to_sym)
+      unknown = step.keys - STEP_KEYS
+      raise ConfigurationError, "#{label}: unknown step option(s) #{unknown.join(', ')}" if unknown.any?
+      unless step[:model].is_a?(String) || step[:model].is_a?(Symbol)
+        raise ConfigurationError, "#{label}: a step needs a model: name, got #{step.inspect}"
+      end
+
+      model = model_name(step[:model], label)
+      attempts = step.fetch(:attempts, 1)
+      unless attempts.is_a?(Integer) && attempts.positive?
+        raise ConfigurationError, "#{label} (#{model}): attempts: must be a positive Integer, got #{attempts.inspect}"
+      end
+      if step.key?(:order) && !step[:order].is_a?(Integer)
+        raise ConfigurationError, "#{label} (#{model}): order: must be an Integer, got #{step[:order].inspect}"
+      end
+
+      params = step[:params] && Params.normalize(step[:params], "#{label} (#{model}) params")
+      normalized = { model:, provider: step[:provider], params:, attempts: }
+      step.key?(:order) ? normalized.merge(order: step[:order]) : normalized
+    end
+
+    def model_name(model, label)
+      name = model.to_s
+      raise ConfigurationError, "#{label}: model names can't be blank" if name.strip.empty?
+
+      name
+    end
+  end
+end

data/lib/squishling/params.rb

@@ -9,8 +9,9 @@ module Squishling
     # overriding RubyLLM's defaults, so these would silently replace the model, the conversation,
     # or the strict output format.
     RESERVED_KEYS = %i[
-      model messages input instructions contents system system_instruction stream stream_options store include
-      response_format text output_config tools tool_choice schema
+      model messages input inputs instructions contents system system_instruction systemInstruction cachedContent
+      stream stream_options store include response_format text output_config outputConfig tools tool_choice
+      toolConfig schema
     ].freeze
 
     module_function

data/lib/squishling/router.rb

@@ -4,9 +4,9 @@ module Squishling
   # Decides, per call, whether a squished method runs its Ruby implementation or the LLM.
   module Router
     # One squished call in progress. `phase` is :routing (deciding, e.g. running squish_when), :ruby (running
-    # the implementation), or :llm (on the LLM path, including any fallback); `escalated` records that squish!
+    # the implementation), or :llm (on the LLM path, including any fallback); `handed_off` records that squish!
     # already sent it to the LLM.
-    Frame = Struct.new(:receiver, :definition, :wrapper, :inputs, :phase, :escalated)
+    Frame = Struct.new(:receiver, :definition, :wrapper, :inputs, :phase, :handed_off)
 
     FRAMES_KEY = :__squishling_frames__
 
@@ -27,7 +27,7 @@ module Squishling
             value = impl.call
           rescue NotImplementedError
             # After squish!, the error came from the LLM path (a fallback, a proc), not a missing implementation.
-            raise if frame.escalated
+            raise if frame.handed_off
 
             return route_to_llm(frame, definition, "not implemented")
           end
@@ -43,7 +43,7 @@ module Squishling
       end
 
       # squish!: hand the call in progress on this receiver to the LLM, with this call's overrides.
-      def escalate(receiver, overrides)
+      def hand_off(receiver, overrides)
         frame = current_frame(receiver)
         raise Error, "#{receiver.class}#squish! called outside a squished method" unless frame
         unless frame.phase == :ruby
@@ -51,7 +51,7 @@ module Squishling
                        "not from squish_when or while already on the LLM path (e.g. from squish_fallback)"
         end
 
-        frame.escalated = true
+        frame.handed_off = true
         route_to_llm(frame, frame.definition.for_call(**overrides), "squish!")
       end