silas 0.3.2 → 0.5.0

data/lib/silas/schedule.rb

@@ -10,33 +10,59 @@ module Silas
   #
   # Identity is the filesystem path under app/agent/schedules (subdirs included):
   # schedules/billing/sweep.rb -> "billing/sweep" -> Agent::Schedules::Billing::Sweep.
-  # Schedules are NOT model-visible capabilities, so they never enter the
-  # definitions digest — adding or removing one cannot diverge an in-flight turn.
+  # Named agents own their schedules the same way they own tools and skills:
+  # app/agents/analyst/schedules/monday_kpis.md -> "agents/analyst/monday_kpis",
+  # and its ticks start THAT agent — a staff member's cron never wakes the root
+  # agent. Schedules are NOT model-visible capabilities, so they never enter
+  # the definitions digest — adding or removing one cannot diverge an
+  # in-flight turn.
   class Schedule
     KINDS = %i[task handler].freeze
 
-    attr_reader :name, :cron, :queue, :kind, :payload
+    attr_reader :name, :cron, :queue, :kind, :payload, :agent_name
 
-    def initialize(name:, cron:, queue:, kind:, payload:)
+    def initialize(name:, cron:, queue:, kind:, payload:, agent_name: nil)
       @name = name
       @cron = cron
       @queue = queue
       @kind = kind
       @payload = payload
+      @agent_name = agent_name
     end
 
     def self.parse(path, root:)
-      rel = path.relative_path_from(root.join("app/agent/schedules"))
-      name = rel.sub_ext("").to_s
+      agents_dir = root.join("app/agents")
+      if path.to_s.start_with?("#{agents_dir}#{File::SEPARATOR}")
+        parse_named(path, agents_dir: agents_dir)
+      else
+        rel = path.relative_path_from(root.join("app/agent/schedules"))
+        name = rel.sub_ext("").to_s
+        case path.extname
+        when ".md" then from_markdown(name, path)
+        when ".rb"
+          const = "Agent::Schedules::" + name.split("/").map(&:camelize).join("::")
+          from_handler(name, const.constantize)
+        end
+      end
+    end
+
+    # app/agents/<agent>/schedules/<rel> — the "agents/" name prefix keeps
+    # names (and therefore recurring keys) collision-free against a root
+    # schedule that happens to share the path shape.
+    def self.parse_named(path, agents_dir:)
+      rel = path.relative_path_from(agents_dir)          # analyst/schedules/monday_kpis.md
+      agent = rel.each_filename.first
+      sched = rel.relative_path_from(Pathname(agent).join("schedules")).sub_ext("").to_s
+      name = "agents/#{agent}/#{sched}"
       case path.extname
-      when ".md" then from_markdown(name, path)
+      when ".md" then from_markdown(name, path, agent_name: agent)
       when ".rb"
-        const = "Agent::Schedules::" + name.split("/").map(&:camelize).join("::")
-        from_handler(name, const.constantize)
+        const = "Agents::#{agent.camelize}::Schedules::" + sched.split("/").map(&:camelize).join("::")
+        from_handler(name, const.constantize, agent_name: agent)
       end
     end
 
-    def self.from_markdown(name, path)
+    def self.from_markdown(name, path, agent_name: nil)
       content = File.read(path)
       # Tolerate leading whitespace/blank lines (e.g. an ERB comment in a
       # generator template renders to an empty first line).
@@ -51,10 +77,10 @@ module Silas
       raise Error, "schedule #{name}: missing `cron:` frontmatter" if cron.nil?
 
       new(name: name, cron: cron.to_s, queue: (frontmatter["queue"] || Silas.config.queue_name).to_s,
-          kind: :task, payload: body.strip)
+          kind: :task, payload: body.strip, agent_name: agent_name)
     end
 
-    def self.from_handler(name, klass)
+    def self.from_handler(name, klass, agent_name: nil)
       unless klass.ancestors.include?(Schedule::Handler)
         raise Error, "#{klass} (schedule #{name}) must inherit Silas::Schedule::Handler"
       end
@@ -62,14 +88,17 @@ module Silas
       raise Error, "schedule #{name}: handler must declare `cron` or `every`" if cron.nil?
 
       new(name: name, cron: cron, queue: (klass.queue || Silas.config.queue_name).to_s,
-          kind: :handler, payload: klass)
+          kind: :handler, payload: klass, agent_name: agent_name)
     end
 
-    # The only behavioural difference between the two forms.
+    # The only behavioural difference between the two forms. A named agent's
+    # task starts THAT agent (its tools, instructions, digest — the loop swaps
+    # the scope in for every turn of the session it creates).
     def trigger!
       case kind
       when :task
-        Silas.agent.start(input: payload, metadata: { "trigger" => "schedule", "schedule" => name })
+        owner = agent_name ? Silas.agent(agent_name) : Silas.agent
+        owner.start(input: payload, metadata: { "trigger" => "schedule", "schedule" => name })
       when :handler
         payload.new(schedule: self).call
       end

data/lib/silas/slack.rb

@@ -43,13 +43,16 @@ module Silas
 
     # Slack signs each request (v0 scheme) — HMAC-SHA256 over "v0:ts:body" plus a
     # 5-minute replay window. Returns true only for a genuine, fresh request.
-    def verify_signature(signing_secret:, timestamp:, body:, signature:, now: Time.now.to_i)
-      return false if signing_secret.blank? || signature.blank? || timestamp.blank?
-      return false if (now - timestamp.to_i).abs > REPLAY_WINDOW
-
-      basestring = "v0:#{timestamp}:#{body}"
-      expected = "v0=" + OpenSSL::HMAC.hexdigest("SHA256", signing_secret, basestring)
-      ActiveSupport::SecurityUtils.secure_compare(expected, signature)
+    # Slack ALWAYS sends a timestamp, so a missing one is refused here rather
+    # than falling through to Webhook's "no timestamp, no window" default.
+    def verify_signature(signing_secret:, timestamp:, body:, signature:, now: Time.current.to_i)
+      return false if timestamp.blank?
+
+      Silas::Webhook.verify_hmac(
+        secret: signing_secret, signature: signature,
+        payload: "v0:#{timestamp}:#{body}", timestamp: timestamp,
+        window: REPLAY_WINDOW, prefix: "v0=", now: now
+      )
     end
   end
 end

data/lib/silas/step_runner.rb

@@ -51,7 +51,12 @@ module Silas
 
     def execute_model_call(turn, index, step)
       assert_definitions_unchanged!(turn)
-      engine = Silas.resolved_engine
+      # Compact BEFORE building messages, inside the isolated step: a crash
+      # anywhere in this step re-runs it, and the compaction claim is
+      # idempotent — a re-executed step sees the identical (compacted) history
+      # its first attempt saw. MessageBuilder reads the row this ensures.
+      Compactor.ensure!(turn)
+      engine = Silas.resolved_adapter
       context = {
         turn: turn,
         index: index,
@@ -64,7 +69,7 @@ module Silas
       }
 
       # Live deltas: the engine yields Events, the buffer coalesces them into
-      # "silas.delta" notifications. A replayed step never reaches this method
+      # "delta.silas" notifications. A replayed step never reaches this method
       # (the completed? guard above), so replay emits nothing. The emitter is
       # created HERE and closed over by the inner block, so around_model_call
       # hooks keep their existing one-argument contract and can't swallow it.
@@ -93,6 +98,9 @@ module Silas
       return if live == turn.definitions_digest
 
       turn.finish!(:failed, reason: "definitions_changed")
+      Silas.instrument(:nondeterminism, turn_id: turn.id,
+                                        was: turn.definitions_digest.to_s[0, 12],
+                                        now: live[0, 12])
       raise NondeterminismError,
             "Tool/skill definitions changed mid-turn (digest #{turn.definitions_digest[0, 12]}… → " \
             "#{live[0, 12]}…). The turn was failed rather than resumed against a different agent."

data/lib/silas/tools/ask_question.rb

@@ -0,0 +1,26 @@
+module Silas
+  module Tools
+    # Parks the turn to ask the HUMAN something — information, not permission.
+    #
+    # It rides the approval machinery end to end (park at zero compute, TTL
+    # expiry, channel ping, the resume gate), differing only in the verdict: an
+    # operator ANSWERS, and the answer text becomes the tool result the model
+    # resumes with. Replay determinism is free — the answer is a persisted row
+    # like any other tool result.
+    class AskQuestion < Tool
+      description "Ask the human operator a question and pause until they answer. " \
+                  "Use when you need information only a person has. The run parks at " \
+                  "zero compute until the answer arrives; the answer is returned as this tool's result."
+      param :question, :string, desc: "The question, complete and self-contained — " \
+                                      "the operator sees nothing but this text."
+      approval :always # the park; ToolInvocation#answer!/decline! settle it
+
+      def call(question:)
+        # pending+approved would execute this, but ToolInvocation#approve!
+        # refuses questions (answer! is their verdict) — reaching here is a
+        # framework bug, never a user mistake.
+        raise Error, "ask_question is answered, not executed — ToolInvocation#answer! settles it"
+      end
+    end
+  end
+end

data/lib/silas/version.rb

@@ -1,3 +1,3 @@
 module Silas
-  VERSION = "0.3.2"
+  VERSION = "0.5.0"
 end

data/lib/silas/webhook.rb

@@ -0,0 +1,47 @@
+require "openssl"
+
+module Silas
+  # Inbound webhook signature verification, shared by every channel.
+  #
+  # Vendors differ only in what they sign and how they label it: Slack signs
+  # "v0:#{timestamp}:#{body}" and prefixes "v0=", GitHub signs the raw body and
+  # prefixes "sha256=", Shopify signs the raw body and Base64-encodes it. The
+  # dangerous parts are identical everywhere — constant-time comparison, a
+  # replay window, and failing closed on a missing secret — so they live here
+  # and get tested once, while the caller supplies the vendor's shape.
+  module Webhook
+    module_function
+
+    REPLAY_WINDOW = 300 # seconds
+
+    # Returns true ONLY for a genuine, fresh request. Every failure path returns
+    # false rather than raising: a webhook endpoint answers 401, it does not 500.
+    #
+    #   secret      the shared signing secret. Blank => false (a channel with no
+    #               secret configured must reject, never accept).
+    #   signature   the header value, exactly as sent.
+    #   payload     the bytes the vendor signed — usually request.raw_post,
+    #               sometimes a basestring built from it. NEVER the parsed
+    #               params: re-serializing changes the bytes and the HMAC.
+    #   timestamp   the vendor's request timestamp, if it sends one. Present =>
+    #               anything outside +/- window is refused as a replay.
+    #   prefix      whatever the vendor puts before the digest ("v0=", "sha256=").
+    #   digest      "hex" (nearly everyone) or "base64" (Shopify, Twilio).
+    def verify_hmac(secret:, signature:, payload:, timestamp: nil, window: REPLAY_WINDOW,
+                    prefix: "", algorithm: "SHA256", digest: :hex, now: Time.current.to_i)
+      return false if secret.blank? || signature.blank?
+      return false if timestamp.present? && window && (now - timestamp.to_i).abs > window
+
+      expected = prefix + hmac(algorithm, secret, payload, digest)
+      ActiveSupport::SecurityUtils.secure_compare(expected, signature)
+    end
+
+    def hmac(algorithm, secret, payload, digest)
+      case digest
+      when :hex    then OpenSSL::HMAC.hexdigest(algorithm, secret, payload)
+      when :base64 then Base64.strict_encode64(OpenSSL::HMAC.digest(algorithm, secret, payload))
+      else raise ArgumentError, "digest must be :hex or :base64, got #{digest.inspect}"
+      end
+    end
+  end
+end

data/lib/silas.rb

@@ -4,6 +4,8 @@ require "active_job/railtie" if defined?(::Rails::Railtie)
 require "active_record/railtie" if defined?(::Rails::Railtie)
 
 require "silas/version"
+require "silas/deprecator"
+require "silas/instrumentation"
 require "silas/errors"
 require "silas/configuration"
 require "silas/ledger"
@@ -17,6 +19,7 @@ require "silas/tools/delegate"
 require "silas/nested_runner"
 require "silas/sandbox"
 require "silas/tools/run_code"
+require "silas/webhook"
 require "silas/channel"
 require "silas/slack"
 require "silas/mcp/client"
@@ -27,23 +30,26 @@ require "silas/inbox/cost"
 require "silas/inbox/delta_broadcaster"
 require "silas/delta_buffer"
 require "silas/budget"
+require "silas/compactor"
 require "silas/registry"
 require "silas/agent"
+require "silas/tools/ask_question"
 require "silas/tools/load_skill"
 require "silas/tools/remember"
 require "silas/tools/recall"
 require "silas/tools/handoff"
 require "silas/mcp/handler"
 require "silas/mcp/server"
-require "silas/engines/base"
+require "silas/adapters/base"
 require "ruby_llm"
-require "silas/engines/ruby_llm"
+require "silas/adapters/ruby_llm"
 require "silas/message_builder"
 require "silas/instructions"
 require "silas/step_runner"
-require "silas/eval" # after engines (ScriptedEngine < Engines::Base)
+require "silas/eval" # after adapters (ScriptedEngine < Adapters::Base)
 require "silas/chat"
 require "silas/doctor"
+require "silas/log_subscriber" if defined?(::ActiveSupport::LogSubscriber)
 
 module Silas
   class << self
@@ -60,14 +66,14 @@ module Silas
     def configure
       yield config
       config.validate!
-      @resolved_engine = nil
+      @resolved_adapter = nil
       @resolved_sandbox = nil
       config
     end
 
     def reset_configuration! # for specs
       @config = nil
-      @resolved_engine = nil
+      @resolved_adapter = nil
       @resolved_sandbox = nil
       @agent = nil
     end
@@ -103,21 +109,29 @@ module Silas
 
     def reset_agent_memo! = (@agent = nil) # after Registry.install! swaps dirs
 
-    # The inference adapter instance. config.engine may be :ruby_llm or any
+    # The inference adapter instance. config.adapter may be :ruby_llm or any
     # object responding to #execute_step (specs, custom).
-    def resolved_engine
-      @resolved_engine ||=
-        case config.engine
-        when :ruby_llm then Engines::RubyLLM.new
+    def resolved_adapter
+      @resolved_adapter ||=
+        case config.adapter
+        when :ruby_llm then Adapters::RubyLLM.new
         when :agent_sdk
-          raise Error, "the :agent_sdk engine was removed in Silas 0.2 — the claude -p " \
+          raise Error, "the :agent_sdk adapter was removed in Silas 0.2 — the claude -p " \
                        "subprocess integration is gone (its subscription-auth rationale was " \
-                       "unreachable). Use engine :ruby_llm, the production path."
-        when Symbol then raise Error, "unknown engine #{config.engine.inspect}"
-        else config.engine
+                       "unreachable). Use adapter :ruby_llm, the production path."
+        when Symbol then raise Error, "unknown adapter #{config.adapter.inspect}"
+        else config.adapter
         end
     end
 
+    # Renamed in 0.4: "engine" meant two unrelated things (the Rails engine at
+    # Silas::Engine, and the inference backend), which is exactly the collision
+    # ActiveJob avoids with QueueAdapters. Removed in 2.0.
+    def resolved_engine
+      Silas.deprecator.warn("Silas.resolved_engine is deprecated; use Silas.resolved_adapter")
+      resolved_adapter
+    end
+
     # ---- scope-aware readers -------------------------------------------------
     # Every reader consults the active AgentScope first (named agent or
     # subagent), falling back to the boot-time config the Registry installed.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: silas
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Daniel St Paul
@@ -133,6 +133,7 @@ files:
 - app/mailers/silas/channel_mailer.rb
 - app/models/concerns/silas/inbox/broadcastable.rb
 - app/models/silas/application_record.rb
+- app/models/silas/compaction.rb
 - app/models/silas/memory.rb
 - app/models/silas/session.rb
 - app/models/silas/step.rb
@@ -151,6 +152,7 @@ files:
 - app/views/silas/inbox/steps/_step.html.erb
 - app/views/silas/inbox/turns/_header.html.erb
 - app/views/silas/inbox/turns/_turn.html.erb
+- config/brakeman.ignore
 - config/routes.rb
 - db/migrate/20260714000001_create_silas_tables.rb
 - db/migrate/20260715000001_add_channel_outbound_markers.rb
@@ -161,6 +163,10 @@ files:
 - db/migrate/20260721000001_create_silas_memories.rb
 - db/migrate/20260724000001_drop_agent_sdk_columns_from_silas_turns.rb
 - db/migrate/20260725000001_add_provider_to_silas_steps.rb
+- db/migrate/20260725000002_create_silas_compactions.rb
+- lib/generators/silas/channel/channel_generator.rb
+- lib/generators/silas/channel/templates/channel.rb.tt
+- lib/generators/silas/channel/templates/controller.rb.tt
 - lib/generators/silas/install/install_generator.rb
 - lib/generators/silas/install/templates/agent.yml
 - lib/generators/silas/install/templates/bin_ci
@@ -174,19 +180,21 @@ files:
 - lib/generators/silas/install/templates/instructions.md
 - lib/generators/silas/install/templates/ruby_llm.rb
 - lib/silas.rb
+- lib/silas/adapters/base.rb
+- lib/silas/adapters/ruby_llm.rb
 - lib/silas/agent.rb
 - lib/silas/agent_scope.rb
 - lib/silas/budget.rb
 - lib/silas/channel.rb
 - lib/silas/chat.rb
+- lib/silas/compactor.rb
 - lib/silas/configuration.rb
 - lib/silas/connection.rb
 - lib/silas/connections.rb
 - lib/silas/delta_buffer.rb
+- lib/silas/deprecator.rb
 - lib/silas/doctor.rb
 - lib/silas/engine.rb
-- lib/silas/engines/base.rb
-- lib/silas/engines/ruby_llm.rb
 - lib/silas/errors.rb
 - lib/silas/eval.rb
 - lib/silas/eval/assertions.rb
@@ -201,7 +209,9 @@ files:
 - lib/silas/inbox/cost.rb
 - lib/silas/inbox/delta_broadcaster.rb
 - lib/silas/instructions.rb
+- lib/silas/instrumentation.rb
 - lib/silas/ledger.rb
+- lib/silas/log_subscriber.rb
 - lib/silas/mcp/client.rb
 - lib/silas/mcp/handler.rb
 - lib/silas/mcp/server.rb
@@ -218,6 +228,7 @@ files:
 - lib/silas/slack.rb
 - lib/silas/step_runner.rb
 - lib/silas/tool.rb
+- lib/silas/tools/ask_question.rb
 - lib/silas/tools/delegate.rb
 - lib/silas/tools/handoff.rb
 - lib/silas/tools/load_skill.rb
@@ -225,6 +236,7 @@ files:
 - lib/silas/tools/remember.rb
 - lib/silas/tools/run_code.rb
 - lib/silas/version.rb
+- lib/silas/webhook.rb
 - lib/tasks/silas_chat.rake
 - lib/tasks/silas_doctor.rake
 - lib/tasks/silas_eval.rake

data/lib/silas/engines/ruby_llm.rb

@@ -1,165 +0,0 @@
-module Silas
-  module Engines
-    # The :ruby_llm adapter: ONE model call per step, streamed, with tool
-    # interception. Silas's Ledger owns tool execution, so tools are registered
-    # as halt-proxies — RubyLLM sees the schemas, but the moment the model
-    # requests a tool the proxy halts the chat loop and the calls are handed
-    # back to the framework untouched.
-    class RubyLLM < Base
-      INTERCEPTED = "__silas_intercepted__".freeze
-
-      def execute_step(context, &on_event)
-        chat = build_chat(context, &on_event)
-
-        response = ActiveSupport::Notifications.instrument("silas.step",
-                                                           turn_id: context[:turn]&.id,
-                                                           index: context[:index],
-                                                           model: context[:model]) do
-          if on_event
-            # Streamed: RubyLLM's accumulator returns a Message identical in
-            # shape to the sync path, so to_result needs no branch. Chunks with
-            # tool-call fragments carry nil/empty content — only text streams.
-            chat.complete do |chunk|
-              text = chunk.content
-              on_event.call(Event.new(type: :text_delta, payload: { text: text })) if text.is_a?(String) && !text.empty?
-            end
-          else
-            chat.complete
-          end
-        end
-
-        to_result(chat, response)
-      end
-
-      private
-
-      def build_chat(context, &on_event)
-        chat = begin
-          ::RubyLLM.chat(model: context[:model])
-        rescue ::RubyLLM::ModelNotFoundError
-          raise Silas::Error,
-                "Model #{context[:model].inspect} is not in ruby_llm's model registry. " \
-                "Newer models may need a registry refresh (`RubyLLM.models.refresh!`), " \
-                "or pick a registry-known model in config.default_model / agent.yml."
-        end
-        chat.with_instructions(context[:system]) if context[:system].present?
-        # agent.yml's final_answer schema: RubyLLM renders the provider's
-        # structured-output dialect and JSON-parses the response back to a
-        # Hash — which to_result persists as a "structured" block.
-        chat.with_schema(context[:final_answer]) if context[:final_answer].present?
-        context[:tools].each { |definition| chat.with_tool(HaltProxy.new(definition)) }
-
-        replay_history(chat, context[:messages])
-
-        if on_event
-          # before_message replaces the deprecated on_new_message (gone in
-          # RubyLLM 2.0). Under streaming it fires BEFORE the HTTP request —
-          # deliberate; don't "fix" the earlier timing.
-          chat.before_message { on_event.call(Event.new(type: :message_start, payload: {})) }
-        end
-        chat
-      end
-
-      # Rebuild the provider conversation from Silas's canonical rows. The last
-      # user message is delivered via ask-equivalent add_message; RubyLLM sends
-      # the whole array on complete.
-      def replay_history(chat, messages)
-        i = 0
-        while i < messages.length
-          msg = messages[i]
-          case msg[:role]
-          when "user"
-            chat.add_message(role: :user, content: msg[:content])
-            i += 1
-          when "assistant"
-            chat.add_message(
-              role: :assistant,
-              content: text_from(msg[:content]),
-              tool_calls: tool_calls_from(msg[:content])
-            )
-            i += 1
-          when "tool"
-            # Anthropic requires every tool_result for one assistant turn to sit
-            # in a single user message. The model can emit parallel tool_use
-            # blocks, so batch all consecutive tool results into one Raw message
-            # (a one-element batch is the ordinary single-tool-call case).
-            first_id = msg[:tool_call_id]
-            blocks = []
-            while i < messages.length && messages[i][:role] == "tool"
-              t = messages[i]
-              blocks << {
-                type: "tool_result",
-                tool_use_id: t[:tool_call_id],
-                content: JSON.generate(t[:content])
-              }
-              i += 1
-            end
-            chat.add_message(role: :tool, tool_call_id: first_id,
-                             content: ::RubyLLM::Content::Raw.new(blocks))
-          else
-            i += 1
-          end
-        end
-      end
-
-      def text_from(blocks)
-        Array(blocks).select { |b| b["type"] == "text" }.map { |b| b["text"] }.join
-      end
-
-      def tool_calls_from(blocks)
-        calls = Array(blocks).select { |b| b["type"] == "tool_call" }
-        return nil if calls.empty?
-
-        calls.to_h do |b|
-          [ b["id"], ::RubyLLM::ToolCall.new(id: b["id"], name: b["name"], arguments: b["arguments"]) ]
-        end
-      end
-
-      # The halt-proxies stop the loop after the assistant's tool_use message
-      # was recorded on the chat; pull the LAST assistant message for the step.
-      def to_result(chat, response)
-        assistant = chat.messages.reverse.find { |m| m.role.to_s == "assistant" } || response
-
-        blocks = []
-        content = assistant.content
-        if content.is_a?(Hash)
-          # with_schema active: RubyLLM parsed the response to a Hash. Persist
-          # it as its own block type — content.to_s here would write Ruby's
-          # Hash#inspect string into the transcript as "text".
-          blocks << { "type" => "structured", "data" => content }
-        elsif content.to_s.present?
-          blocks << { "type" => "text", "text" => content.to_s }
-        end
-
-        tool_calls = (assistant.tool_calls || {}).values.map do |tc|
-          blocks << { "type" => "tool_call", "id" => tc.id, "name" => tc.name,
-                      "arguments" => tc.arguments || {} }
-          ToolCall.new(id: tc.id, name: tc.name, arguments: (tc.arguments || {}).stringify_keys)
-        end
-
-        Result.new(
-          blocks: blocks,
-          tool_calls: tool_calls,
-          stop_reason: tool_calls.any? ? "tool_use" : "end_turn",
-          usage: { input_tokens: assistant.tokens&.input, output_tokens: assistant.tokens&.output }
-        )
-      end
-
-      # Presents an Silas tool schema to RubyLLM; halts instead of executing.
-      class HaltProxy < ::RubyLLM::Tool
-        def initialize(definition)
-          super()
-          @definition = definition
-        end
-
-        def name = @definition["name"]
-        def description = @definition["description"]
-        def params_schema = @definition["input_schema"]
-
-        def execute(**)
-          ::RubyLLM::Tool::Halt.new(INTERCEPTED)
-        end
-      end
-    end
-  end
-end