pinecall 0.0.1

data/lib/pinecall/rules.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pinecall
+  # The framework's own words in the identity block: the rules, the protocols, and the channel's.
+  # English for every agent: a model follows English instructions and answers in any language.
+  # Constant within a call, so they stay in the cached prompt prefix. Word for word the TypeScript
+  # package's `built-in-rules.ts`.
+  module Rules
+    RULES = [
+      "- Invent nothing: if it did not come from a tool or from the knowledge, do not say it.",
+      "- One question per turn, and wait for the answer.",
+      "- Answer in the language the caller speaks."
+    ].join("\n").freeze
+
+    PROTOCOLS = [
+      "- To act, call a tool; saying you have done something does not do it.",
+      "- Before an irreversible action read back what you are about to do and wait for an explicit yes.",
+      "- If you cannot solve it, say so and offer to hand over to a person."
+    ].join("\n").freeze
+
+    SPOKEN = "You are on a phone call. Everything you write is read aloud by a voice: short spoken sentences, " \
+             "no lists, no bold, no symbols, no links. Say an email or a web address the way a person says it out loud."
+
+    ON_A_WEBSITE = "You are in a written chat on a website. Markdown is fine: short paragraphs, a list when there " \
+                   "are steps, bold for the one thing that matters."
+
+    ON_WHATSAPP = "You are on WhatsApp. Use its formatting: *bold*, _italic_, no headings, no tables, short messages."
+
+    module_function
+
+    # How to write on this channel and medium: WhatsApp's formatting, a website's Markdown, or speech.
+    def channel_rules_for(channel, medium)
+      return ON_WHATSAPP if channel.to_s == "whatsapp"
+
+      channel.to_s == "web" && medium.to_s == "text" ? ON_A_WEBSITE : SPOKEN
+    end
+  end
+end

data/lib/pinecall/serve/held.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# The agents a process holds, and leaving: a drain, then the socket closed, once.
+
+module Pinecall
+  module Serve
+    # What `Pinecall.serve` and `serve start` hold: the client, the agents mounted on it.
+    class Held
+      attr_reader :client, :mounted
+
+      def initialize(client, mounted)
+        @client = client
+        @mounted = mounted
+        @stopped = Thread::Queue.new
+        @lock = Mutex.new
+        @drained = nil
+      end
+
+      # Drain every agent, then close the socket; asked twice, the first answer. Returns the drain.
+      def stop
+        @lock.synchronize do
+          return @drained unless @drained.nil?
+
+          @drained = @client.drain
+          close
+          @drained
+        end
+      end
+
+      # Close without draining: a second signal, or a stop the gateway already made.
+      def close
+        @client.close
+        @stopped.close
+      end
+
+      # Block until the socket is closed.
+      def join = @stopped.pop
+    end
+  end
+end

data/lib/pinecall/serve/loading.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# What the serve entry is told and loads: its flags, the class in a file, and a state field by field.
+
+module Pinecall
+  module Serve
+    # Thrown when what was asked cannot be served at all; the entry exits 2 with its sentence.
+    class CannotServe < Error; end
+
+    # One agent file and the slug it is served as.
+    Served = Data.define(:file, :slug)
+
+    # The flags of one verb, as the CLI passes them.
+    Flags = Data.define(:served, :console, :events, :prod, :state, :channel, :medium, :show_machine)
+
+    module Loading
+      module_function
+
+      # `--file` and `--slug` paired by place; the rest by name. A flag nobody declared is refused.
+      def parse(argv)
+        found = { files: [], slugs: [], console: false, events: false, prod: false, state: {}, channel: "phone", medium: nil,
+                  show_machine: false }
+        words = argv.dup
+        until words.empty?
+          word = words.shift
+          case word
+          when "--file" then found[:files] << value_of(word, words)
+          when "--slug" then found[:slugs] << value_of(word, words)
+          when "--state" then found[:state].merge!(as_state(value_of(word, words)))
+          when "--channel" then found[:channel] = value_of(word, words)
+          when "--console", "--events", "--prod" then found[word.delete_prefix("--").to_sym] = true
+          when "--show-machine" then found[:show_machine] = true
+          when "--medium" then found[:medium] = value_of(word, words)
+          else raise CannotServe, "serve has no flag #{word}"
+          end
+        end
+        flags(found)
+      end
+
+      # `field=json`: the value is the field's, as JSON; a value that is not JSON is refused by its field.
+      def as_state(pair)
+        field, equals, value = pair.to_s.partition("=")
+        raise CannotServe, "--state #{pair}: a field, =, and its value as JSON" if field.empty? || equals.empty?
+
+        { field.to_sym => JSON.parse(value, symbolize_names: true) }
+      rescue JSON::ParserError
+        raise CannotServe, "--state #{field}: its value is not JSON"
+      end
+
+      # The class the file defines, refused when its own `slug` says another than the one it is served as.
+      def load_served(served)
+        klass = load_agent(served.file)
+        declared = klass.declared_slug
+        if !declared.nil? && declared.to_s != served.slug
+          raise CannotServe, "#{served.file} says its slug is #{declared}, and it is served as #{served.slug}: the slug is its folder's name"
+        end
+
+        klass
+      end
+
+      # The last `Pinecall::Agent` the file defines.
+      def load_agent(file)
+        path = File.expand_path(file)
+        raise CannotServe, "no agent at #{path}" unless File.exist?(path)
+
+        before = Agent.written.dup
+        begin
+          loaded = require path
+        rescue ScriptError, LoadError => e
+          raise CannotServe, "#{path} did not load: #{e.message}"
+        end
+        # `require` answers false for a file already loaded: its class is found by its source.
+        written = loaded ? Agent.written - before : Agent.written.select { |klass| klass.source_file == path }
+        written = written.select(&:name)
+        raise CannotServe, "#{path} declares no Pinecall::Agent" if written.empty?
+
+        written.last
+      end
+
+      def value_of(flag, words)
+        value = words.shift
+        raise CannotServe, "#{flag} takes a value" if value.nil? || value.start_with?("--")
+
+        value
+      end
+
+      def flags(found)
+        files, slugs = found.values_at(:files, :slugs)
+        if files.empty? || files.length != slugs.length
+          raise CannotServe, "serve takes one --slug for each --file, and at least one of each"
+        end
+        unless Wire::Enums::CHANNEL.include?(found[:channel]) && [nil, *Wire::Enums::MEDIUM].include?(found[:medium])
+          raise CannotServe, "--channel is phone, web or whatsapp, and --medium is voice or text"
+        end
+
+        Flags.new(served: files.zip(slugs).map { |file, slug| Served.new(file:, slug:) },
+                  console: found[:console], events: found[:events], prod: found[:prod], state: found[:state],
+                  channel: found[:channel], medium: found[:medium], show_machine: found[:show_machine])
+      end
+    end
+  end
+end

data/lib/pinecall/serve/viewing.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pinecall
+  module Serve
+    # The one console verb an agent's own process answers: its class's panel, for a conversation.
+    # Every other verb is the CLI's companion's. Word for word the TypeScript serve entry's answers.
+    module Viewing
+      ONLY_THE_VIEW = "this process answers only view.render: the console's other verbs are the CLI's"
+
+      module_function
+
+      # The class's panel for the conversation asked, or a refusal with its status.
+      def answer(klass, slug, verb, asked)
+        raise DevRefused.new(404, ONLY_THE_VIEW) unless verb == "view.render"
+
+        who = a_conversation(slug, asked)
+        raise DevRefused.new(404, "#{slug} declares no view: nothing in this directory draws a panel") if klass.declared_panel.nil?
+
+        begin
+          Panel.draw(klass, who)
+        rescue StandardError => e
+          # The pane says it, and the conversation's screen keeps working.
+          raise DevRefused.new(502, "#{slug}'s view failed: #{e.message}")
+        end
+      end
+
+      def a_conversation(slug, asked)
+        raise DevRefused.new(422, "a panel is asked for with a JSON object") unless asked.is_a?(Hash)
+
+        named = %i[contact call].to_h do |name|
+          value = asked[name]
+          raise DevRefused.new(422, "#{name} is a name, and it was missing") unless value.is_a?(String) && !value.empty?
+
+          [name, value]
+        end
+        Panel::Who.new(agent: slug, **named)
+      end
+    end
+  end
+end

data/lib/pinecall/serve.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "serve/loading"
+require_relative "serve/held"
+require_relative "serve/viewing"
+
+module Pinecall
+  # The entry the one `pinecall` CLI starts a Ruby agent with: `start` holds the agents and serves
+  # their calls, `prompt` prints a prompt. The CLI runs it as
+  # `ruby -r pinecall -e 'exit Pinecall::Serve.main(ARGV)' -- start --file … --slug …`.
+  #
+  # It reads its door from `PINECALL_URL`, `PINECALL_KEY` and `PINECALL_ENV` alone, and leaves on
+  # SIGINT, SIGTERM or the end of its stdin, draining first; a second signal leaves now.
+  module Serve
+    USAGE = <<~USAGE
+      usage: serve start --file <agent.rb> --slug <slug> [--file … --slug …] [--console] [--events] [--prod]
+             serve prompt --file <agent.rb> --slug <slug> [--state field=json]… [--channel name] [--show-machine]
+    USAGE
+
+    NO_DOOR = "serve start reads PINECALL_URL and PINECALL_KEY from its environment, and one was not set"
+
+    WORLDS = %w[sandbox production].freeze
+
+    module_function
+
+    # Run one verb and answer its exit status: 2 when it cannot run at all, with the sentence on `err`.
+    def main(argv, out: $stdout, err: $stderr, env: ENV, input: $stdin, signals: nil)
+      verb, *rest = argv
+      case verb
+      when "start" then start(Loading.parse(rest), out:, err:, env:, input:, signals:)
+      when "prompt" then prompt(Loading.parse(rest), out:)
+      else err.puts(USAGE) || 2
+      end
+    rescue CannotServe, NotConnected => e
+      err.puts(e.message)
+      2
+    end
+
+    # Hold every agent named until asked to leave; 0 once they drained.
+    def start(flags, out:, err:, env:, input:, signals:)
+      client = client_from(env, prod: flags.prod)
+      classes = flags.served.map { |served| [served, Loading.load_served(served)] }
+      said(client, out:, err:, events: flags.events)
+      mounted = classes.map do |served, klass|
+        held = Pinecall.mount(klass, client:, slug: served.slug, takes_unclaimed: !flags.console)
+        held.agent.on_dev { |verb, data| Viewing.answer(klass, served.slug, verb, data) }
+        held
+      end
+      held = Held.new(client, mounted)
+      asked = signals || trapped
+      client.on_stopped { |why| err.puts(why) || asked.push(:stopped) }
+      client.connect
+      Thread.new { ended(input, asked) }
+      leave(held, asked, err)
+    end
+
+    # Load the class, open it in the state the pairs name, and print its prompt. No gateway, no key.
+    def prompt(flags, out:)
+      klass = Loading.load_served(flags.served.first)
+      instance = klass.new.seal
+      # A call of its own, so the channel's block is the one this channel and medium get.
+      instance.serving(CallWorld.new(id: "", contact: "", channel: flags.channel, medium: flags.medium) { |*| nil })
+      instance.start_in(flags.state) unless flags.state.empty?
+      out.puts(Pinecall.show_prompt(instance, line: { channel: flags.channel }))
+      out.puts("\n#{machine(instance)}") if flags.show_machine
+      0
+    end
+
+    # The tools the class declares, marking the ones this state shows, under the stage.
+    def machine(instance)
+      shown = instance.visible_tools.map { |spec| spec[:name] }
+      stage = instance.respond_to?(:stage) ? " stage: #{instance.stage}" : ""
+      header = "#{Prompt.header_for("tools")}#{stage}"
+      return "#{header}\n\n  this agent declares no tools" if instance.tools.empty?
+
+      declared = instance.class.declared_tools.values
+      width = declared.map { |one| one.name.length }.max
+      lines = declared.map do |one|
+        visible = shown.include?(one.name.to_s)
+        "  #{visible ? "●" : "○"} #{one.name.to_s.ljust(width)}  #{gated_by(instance, one.options, visible)}"
+      end
+      [header, "", *lines].join("\n")
+    end
+
+    # What gates a tool: its stages, its `when`, or nothing. A tool hidden in its own stage is always
+    # its `when`'s doing, and says so.
+    def gated_by(instance, options, visible)
+      stages = options[:stage] && Array(options[:stage]).map(&:to_sym)
+      return options[:when].nil? ? "always" : "when(state)" if stages.nil?
+
+      here = instance.respond_to?(:stage) ? instance.stage : nil
+      named = stages.join(" · ")
+      !visible && !here.nil? && stages.include?(here) ? "#{named} · when(state) says no" : named
+    end
+
+    # Where the calls went, and what became of the tools running: one line on stderr.
+    def drain_line(drained)
+      return "draining · no live calls" if drained.handed + drained.parked + drained.tools == 0
+
+      parts = ["draining"]
+      parts << "#{plural(drained.handed, "live call")} handed over" if drained.handed.positive?
+      parts << "#{plural(drained.parked, "live call")} kept for the next process" if drained.parked.positive?
+      parts << "#{plural(drained.finished, "tool")} finished" if drained.finished.positive?
+      parts << "#{plural(drained.tools - drained.finished, "tool")} cut" if drained.tools > drained.finished
+      parts.join(" · ")
+    end
+
+    def plural(count, noun) = "#{count} #{noun}#{count == 1 ? "" : "s"}"
+
+    def client_from(env, prod:)
+      url, key = env["PINECALL_URL"], env["PINECALL_KEY"]
+      raise CannotServe, NO_DOOR if url.to_s.empty? || key.to_s.empty?
+
+      world = prod ? "production" : env["PINECALL_ENV"]
+      world = nil if world.to_s.empty?
+      raise CannotServe, "PINECALL_ENV is sandbox or production, not #{world}" unless world.nil? || WORLDS.include?(world)
+
+      Client.new(url:, api_key: key, env: world)
+    end
+
+    # Listening starts before connect, so `agent.registered` is the first line of a pipe. A pipe's
+    # $stdout is buffered: each line is flushed, or the CLI waiting on it sees it only at exit.
+    def said(client, out:, err:, events:)
+      client.on_entries do |entry|
+        if events
+          out.puts(JSON.generate({ type: entry.type, agent: entry.agent, call: entry.call, data: entry.data }))
+        elsif entry.type == "agent.registered"
+          out.puts("#{entry.agent}  · answering as #{entry.data[:app]}")
+        end
+        out.flush
+      end
+      client.on_errors { |error| err.puts("#{error.class}: #{error.message}") }
+    end
+
+    # A trap only pushes: the main thread does the leaving, as a trap may not take a lock.
+    def trapped
+      asked = Thread::Queue.new
+      %w[INT TERM].each { |signal| Signal.trap(signal) { asked.push(:signalled) } }
+      asked
+    end
+
+    # The process that started this one is gone when its end of the pipe closes.
+    def ended(input, asked)
+      input.read
+    rescue IOError, SystemCallError
+      nil
+    ensure
+      asked.push(:ended)
+    end
+
+    # The first reason drains (unless the org already stopped it); only a second signal closes at
+    # once. The end of stdin is not one: the CLI passes a signal on and closes the pipe together.
+    def leave(held, asked, err)
+      if asked.pop == :stopped
+        held.close
+        return 0
+      end
+      outcome = Thread::Queue.new
+      Thread.new { outcome.push(held.stop) }
+      Thread.new do
+        nil until asked.pop == :signalled
+        outcome.push(:again)
+      end
+      drained = outcome.pop
+      drained == :again ? held.close : err.puts(drain_line(drained))
+      0
+    end
+  end
+end

data/lib/pinecall/testing.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "../pinecall"
+
+module Pinecall
+  # An in-process fake gateway for offline (ring 0) tests.
+  #
+  # Answers register/configure, records every command, and lets a test drive calls, tool calls
+  # and events.
+  #
+  #     pc = Pinecall::Testing::Gateway.new
+  #     Pinecall.mount(ClinicaNorte, client: pc)
+  #     call = pc.call_started(from: "+34600123456")
+  #     call.tool("find_patient", name: "Marta Ruiz", phone: "+34600123456")
+  #     assert_includes call.prompt, "Marta Ruiz"
+  module Testing
+    # A call driven by a test.
+    class Fake
+      attr_reader :id, :gateway
+
+      def initialize(gateway, id)
+        @gateway = gateway
+        @id = id
+      end
+
+      # Simulate a tool call; returns the `tool.result` data.
+      def tool(name, **arguments)
+        call_id = "tc_#{@gateway.next_seq}"
+        @gateway.deliver("tool.call", { call_id:, name: name.to_s, arguments: }, call: @id)
+        @gateway.settled { |sent| sent.type == "tool.result" && sent.data[:call_id] == call_id }
+      end
+
+      # Deliver an external event from the backend (`from: "app"`) or a participant.
+      def fact(name, data = {}, from: "app", identity: nil)
+        payload = { name: name.to_s, data:, source: from.to_s }
+        payload[:identity] = identity unless identity.nil?
+        @gateway.deliver("event.received", payload, call: @id)
+        @gateway.settle
+      end
+
+      # Deliver a caller turn.
+      def said(text)
+        @gateway.deliver("turn.user", { text:, speech_id: "sp_#{@gateway.next_seq}", metrics: {} }, call: @id)
+        @gateway.settle
+      end
+
+      # Deliver `call.ended`.
+      def ended(reason: "caller_hung_up")
+        @gateway.deliver("call.ended", { reason:, ended_by: "caller", ended_at: Time.now.to_f, duration_s: 1.0 },
+                         call: @id)
+        @gateway.settle
+      end
+
+      # The last `view` block sent.
+      def prompt = block("view")
+
+      # The last text sent for a prompt block.
+      def block(name) = last("prompt.set", name: name.to_s)&.dig(:text)
+
+      # Names of the currently visible tools.
+      def tools = (last("tools.set")&.dig(:tools) || []).map { |spec| spec[:name] }
+
+      # The last state sent.
+      def state = last("state.set")&.dig(:state) || {}
+
+      # Commands sent for this call, in order.
+      def commands = @gateway.commands.select { |sent| sent.call == @id }
+
+      # Data of the last command of `type` whose fields match `matching`.
+      def last(type, **matching)
+        commands.reverse.find do |sent|
+          sent.type == type && matching.all? { |field, value| sent.data[field] == value }
+        end&.data
+      end
+    end
+
+    # Stands in for `Pinecall::Client` in `Pinecall.mount`.
+    class Gateway
+      attr_reader :commands, :agents
+
+      def initialize
+        @commands = []
+        @agents = {}
+        @seq = 0
+        @errors = []
+        @found = []
+        @searched = []
+      end
+
+      # The chunks every search of this gateway answers with: `{ path:, heading:, text: }`.
+      def finds(*chunks)
+        @found = chunks
+        self
+      end
+
+      # Every search asked of this gateway, in order: `{ call:, query:, k: }`.
+      attr_reader :searched
+
+      # Same signature as `Pinecall::Client#search`.
+      def search(call, query, k: nil)
+        @searched << { call:, query:, k: }
+        @found
+      end
+
+      def sdk = "pinecall-ruby-testing/#{VERSION}"
+
+      # Same signature as `Pinecall::Client#agent`.
+      def agent(slug, **options)
+        @agents[slug] = Client::Agent.new(slug, options, self)
+      end
+
+      # Record a command and answer it if the gateway would.
+      def send_command(type:, agent:, call:, data:, id: nil)
+        frame = Wire.command(type:, agent:, call:, data:, id:)
+        @commands << frame
+        answer(frame)
+        frame
+      end
+
+      def seen(_event, _call) = nil
+
+      def on_error(error)
+        @errors << error
+        warn("pinecall testing: #{error.class}: #{error.message}")
+      end
+
+      # Unhandled errors, for assertions.
+      attr_reader :errors
+
+      # Start a call and return its `Fake` handle; `state:` is the state its opener asked for.
+      def call_started(id: nil, channel: "web", from: "+34600000000", to: "+34910000000", caller: nil, state: nil)
+        id ||= "CA_#{next_seq}"
+        started = { channel:, direction: "inbound", from:, to:, caller:, started_at: Time.now.to_f }
+        deliver("call.started", state.nil? ? started : started.merge(state:), call: id)
+        settle
+        Fake.new(self, id)
+      end
+
+      # Hand this process a call mid-conversation, in `state`; returns its `Fake` handle.
+      def call_attached(state:, id: nil, from: "+34600000000", claimed: nil)
+        id ||= "CA_#{next_seq}"
+        started = { channel: "web", direction: "inbound", from:, to: "+34910000000", caller: nil, started_at: Time.now.to_f }
+        deliver("call.attached", { app: "app_test", started:, state:, seq: next_seq, claimed: }, call: id)
+        settle
+        Fake.new(self, id)
+      end
+
+      # Deliver an entry to the agent.
+      def deliver(type, data, call: nil, agent: @agents.keys.first)
+        entry = Wire::Entry.new(seq: next_seq, ts: Time.now.to_f, call:, agent:, type:,
+                                    ephemeral: Wire::Codec.ephemeral?(type), data:)
+        @agents[agent]&.take(entry)
+        entry
+      end
+
+      # Wait until the call threads are idle.
+      def settle(within_s: 2)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + within_s
+        sleep(0.002) while Thread.list.count { |thread| thread.status == "run" } > 1 &&
+                           Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
+        sleep(0.01)
+        nil
+      end
+
+      # Wait for a command matching the block and return its data.
+      def settled(within_s: 2)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + within_s
+        loop do
+          found = @commands.reverse.find { |sent| yield(sent) }
+          return found.data unless found.nil?
+          raise Error, "the app never sent it" if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+
+          sleep(0.005)
+        end
+      end
+
+      def next_seq = @seq += 1
+
+      # Like the real gateway, only register/configure get a reply.
+      def answer(frame)
+        case frame.type
+        when "agent.register"
+          deliver("agent.registered", { app: "app_test", routes: frame.data[:routes] }, agent: frame.agent)
+        when "agent.configure"
+          deliver("agent.configured", { changed: frame.data[:config].keys.map(&:to_s) }, agent: frame.agent)
+        end
+      end
+    end
+  end
+end

data/lib/pinecall/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Pinecall
+  # Set by the maintainer at release time.
+  VERSION = "0.0.1"
+end

data/lib/pinecall/view.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Pinecall
+  # An ERB template for the dynamic region of the prompt, rendered with the state in scope.
+  #
+  #     <% if stage == :identify -%>
+  #     Saluda y pide nombre y teléfono.
+  #     <% end -%>
+  #
+  # The view carries the operator's authority, so never splice external content (memory,
+  # knowledge results) into it; that reaches the model as tool results in the history.
+  #
+  # In scope: every state field by name, `resumed`, `call[:channel]`, `call[:claimed]` (the page
+  # code this call claimed, or nil), `remembers?(text)`.
+  class View
+    # Default location: `views/<slug>.erb` next to the class's file.
+    def self.beside(file, slug) = File.join(File.dirname(file), "views", "#{slug}.erb")
+
+    # Load a template file; the path is kept so errors report the template line.
+    def self.file(path)
+      raise Error, "there is no view at #{path}" unless File.exist?(path)
+
+      new(File.read(path), path)
+    end
+
+    def self.inline(template, called = "(inline view)") = new(template, called)
+
+    attr_reader :path
+
+    def initialize(template, path)
+      @path = path
+      @erb = ERB.new(template, trim_mode: "-")
+      @erb.filename = path
+    end
+
+    def render(reading) = tidy(@erb.result(Context.new(reading).binding_for_the_template))
+
+    # Strip trailing spaces, collapse blank-line runs, trim both ends.
+    def tidy(text)
+      text.lines.map { |line| line.rstrip + "\n" }.join.gsub(/\n{3,}/, "\n\n").strip
+    end
+
+    # Template scope: state fields by name plus a few helpers; unknown names raise.
+    class Context
+      def initialize(reading)
+        @reading = reading
+      end
+
+      def binding_for_the_template = binding
+
+      # Join items one per line.
+      def each_line(items) = Array(items).map { |item| item.to_s.strip }.join("\n")
+
+      # The whole reading, to pass on.
+      def state = @reading
+
+      def respond_to_missing?(name, include_private = false)
+        @reading.respond_to?(name) || super
+      end
+
+      def method_missing(name, *args, &block)
+        return @reading.public_send(name, *args, &block) if @reading.respond_to?(name)
+
+        super
+      end
+    end
+  end
+end