pinecall 0.0.1

data/lib/pinecall/wire/shapes_parts.rb

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+# The shapes the events, commands and doors are made of.
+
+module Pinecall
+  module Wire
+    module Shapes
+      PARTS = {
+        "Contact" => {
+          id: { kind: :str },
+          phone: { kind: :str },
+          name: { kind: :str },
+          email: { kind: :str },
+          external_id: { kind: :str }
+        }.freeze,
+        "Route" => {
+          channel: { kind: :ref, ref: "Channel", required: true },
+          number: { kind: :str, null: true, required: true },
+          label: { kind: :str }
+        }.freeze,
+        "Supervisor" => {
+          id: { kind: :str, required: true },
+          name: { kind: :str }
+        }.freeze,
+        "MemoryFact" => {
+          id: { kind: :str },
+          text: { kind: :str, required: true },
+          category: { kind: :str },
+          score: { kind: :float },
+          source: { kind: :str }
+        }.freeze,
+        "MemoryOp" => {
+          op: { kind: :enum, values: %w[recall remember forget], required: true },
+          contact: { kind: :str },
+          query: { kind: :str },
+          facts: { kind: :list, items: { kind: :ref, ref: "MemoryFact" }, required: true },
+          took_ms: { kind: :float, required: true }
+        }.freeze,
+        "DocSource" => {
+          id: { kind: :str, required: true },
+          base: { kind: :str },
+          path: { kind: :str, required: true },
+          heading: { kind: :str },
+          score: { kind: :float, required: true },
+          excerpt: { kind: :str }
+        }.freeze,
+        "CostRow" => {
+          provider: { kind: :str, required: true },
+          model: { kind: :str, required: true },
+          unit: { kind: :enum, values: %w[input_tokens cached_input_tokens cache_creation_tokens output_tokens characters audio_seconds requests session_seconds minutes], required: true },
+          quantity: { kind: :float, required: true },
+          unit_price_usd: { kind: :float, required: true },
+          usd: { kind: :float, required: true }
+        }.freeze,
+        "UnpricedRow" => {
+          provider: { kind: :str, required: true },
+          model: { kind: :str, required: true }
+        }.freeze,
+        "Cost" => {
+          usd: { kind: :float, required: true },
+          rows: { kind: :list, items: { kind: :ref, ref: "CostRow" }, required: true },
+          unpriced: { kind: :list, items: { kind: :ref, ref: "UnpricedRow" }, required: true }
+        }.freeze,
+        "Entry" => {
+          seq: { kind: :int, required: true },
+          ts: { kind: :float, required: true },
+          call: { kind: :str, null: true, required: true },
+          agent: { kind: :str, required: true },
+          type: { kind: :str, required: true },
+          ephemeral: { kind: :bool, required: true },
+          data: { kind: :json, required: true }
+        }.freeze,
+        "Command" => {
+          type: { kind: :str, required: true },
+          agent: { kind: :str, required: true },
+          call: { kind: :str, null: true, required: true },
+          id: { kind: :str },
+          data: { kind: :json, required: true }
+        }.freeze,
+        "Metadata" => {
+          model_name: { kind: :str, null: true },
+          model_provider: { kind: :str, null: true }
+        }.freeze,
+        "TurnMetadata" => {
+          model_name: { kind: :str },
+          model_provider: { kind: :str }
+        }.freeze,
+        "GoldenQuestion" => {
+          asks: { kind: :str, required: true },
+          expects: { kind: :str, required: true }
+        }.freeze,
+        "GoldenMiss" => {
+          asks: { kind: :str, required: true },
+          expects: { kind: :str, required: true },
+          found: { kind: :list, items: { kind: :str }, required: true }
+        }.freeze,
+        "KnowledgeBase" => {
+          base: { kind: :str, required: true },
+          chunks: { kind: :int, required: true },
+          model: { kind: :str, required: true },
+          pushed_at: { kind: :float, required: true }
+        }.freeze,
+        "ContactFact" => {
+          id: { kind: :str },
+          text: { kind: :str, required: true },
+          category: { kind: :str },
+          source: { kind: :str },
+          valid_from: { kind: :float, required: true },
+          invalidated_at: { kind: :float, null: true, required: true }
+        }.freeze,
+        "MemoryQuestion" => {
+          holds: { kind: :list, items: { kind: :str }, required: true },
+          asks: { kind: :str, required: true },
+          expects: { kind: :list, items: { kind: :str }, required: true }
+        }.freeze,
+        "MemoryMiss" => {
+          asks: { kind: :str, required: true },
+          missing: { kind: :list, items: { kind: :str }, required: true },
+          found: { kind: :list, items: { kind: :str }, required: true }
+        }.freeze,
+        "ExtractionExpected" => {
+          writes: { kind: :list, items: { kind: :str }, default: [] },
+          never: { kind: :list, items: { kind: :str }, default: [] },
+          never_says: { kind: :list, items: { kind: :str }, default: [] },
+          invalidates: { kind: :list, items: { kind: :str }, default: [] }
+        }.freeze,
+        "ExtractionGolden" => {
+          name: { kind: :str, required: true },
+          said: { kind: :list, items: { kind: :tuple, members: [{ kind: :str }, { kind: :str }] }, required: true },
+          holds: { kind: :list, items: { kind: :str }, default: [] },
+          plants: { kind: :list, items: { kind: :str }, default: [] },
+          channel: { kind: :ref, ref: "Channel", default: "phone" },
+          expect: { kind: :ref, ref: "ExtractionExpected", default: {} }
+        }.freeze,
+        "ExtractionBroke" => {
+          check: { kind: :str, required: true },
+          detail: { kind: :str, required: true }
+        }.freeze,
+        "ExtractionJudged" => {
+          name: { kind: :str, required: true },
+          held: { kind: :bool, required: true },
+          wrote: { kind: :list, items: { kind: :str }, default: [] },
+          refused: { kind: :list, items: { kind: :str }, default: [] },
+          broke: { kind: :list, items: { kind: :ref, ref: "ExtractionBroke" }, default: [] }
+        }.freeze,
+        "UserTurn" => {
+          role: { kind: :const, const: "user", required: true },
+          speech_id: { kind: :str, required: true },
+          item_id: { kind: :str },
+          text: { kind: :str, required: true },
+          language: { kind: :str },
+          transcript_confidence: { kind: :float },
+          metrics: { kind: :ref, ref: "UserTurnMetrics", required: true }
+        }.freeze,
+        "AgentTurn" => {
+          role: { kind: :const, const: "agent", required: true },
+          speech_id: { kind: :str, required: true },
+          item_id: { kind: :str },
+          text: { kind: :str, required: true },
+          interrupted: { kind: :bool, required: true },
+          metrics: { kind: :ref, ref: "AgentTurnMetrics", required: true }
+        }.freeze,
+        "ToolRun" => {
+          call_id: { kind: :str, required: true },
+          name: { kind: :str, required: true },
+          arguments: { kind: :json, required: true },
+          speech_id: { kind: :str },
+          status: { kind: :enum, values: %w[running done failed], required: true },
+          output: { kind: :any },
+          error: { kind: :str },
+          summary: { kind: :str },
+          duration_s: { kind: :float },
+          seq: { kind: :int, required: true }
+        }.freeze,
+        "PromptBlockState" => {
+          hash: { kind: :str, required: true },
+          chars: { kind: :int, required: true },
+          seq: { kind: :int, required: true }
+        }.freeze,
+        "Confirm" => {
+          tool: { kind: :str, required: true },
+          call_id: { kind: :str, required: true },
+          audience: { kind: :str, required: true },
+          phrase: { kind: :str, required: true },
+          status: { kind: :enum, values: %w[pending granted declined], required: true },
+          said: { kind: :str },
+          reason: { kind: :str }
+        }.freeze,
+        "Handoff" => {
+          active: { kind: :bool, required: true },
+          by: { kind: :ref, null: true, ref: "Supervisor", required: true }
+        }.freeze,
+        "TransferState" => {
+          to: { kind: :str, required: true },
+          mode: { kind: :ref, null: true, ref: "TransferMode" },
+          status: { kind: :enum, values: %w[requested done failed], required: true },
+          by: { kind: :enum, values: %w[agent supervisor], required: true }
+        }.freeze,
+        "AttentionState" => {
+          reason: { kind: :str, required: true },
+          wait_s: { kind: :float, required: true },
+          status: { kind: :enum, values: %w[open answered lapsed], required: true },
+          asked_at: { kind: :float, required: true },
+          by: { kind: :ref, null: true, ref: "Supervisor", required: true }
+        }.freeze,
+        "LiveTranscript" => {
+          user: { kind: :str, null: true, required: true },
+          agent: { kind: :str, null: true, required: true }
+        }.freeze,
+        "Gap" => {
+          from_seq: { kind: :int, required: true },
+          to_seq: { kind: :int, required: true }
+        }.freeze,
+        "LoggedError" => {
+          seq: { kind: :int, required: true },
+          code: { kind: :str, required: true },
+          message: { kind: :str, required: true }
+        }.freeze,
+        "Participant" => {
+          identity: { kind: :str, required: true },
+          kind: { kind: :ref, ref: "ParticipantKind", required: true },
+          name: { kind: :str },
+          joined_at: { kind: :float, required: true },
+          speaking: { kind: :bool, required: true },
+          attributes: { kind: :json, required: true }
+        }.freeze,
+        "Room" => {
+          name: { kind: :str, required: true },
+          sid: { kind: :str, required: true },
+          participants: { kind: :list, items: { kind: :ref, ref: "Participant" }, required: true },
+          caller: { kind: :str, null: true, required: true }
+        }.freeze,
+        "ReceivedEvent" => {
+          seq: { kind: :int, required: true },
+          name: { kind: :str, required: true },
+          source: { kind: :ref, ref: "EventSource", required: true },
+          identity: { kind: :str }
+        }.freeze,
+        "CustomNote" => {
+          seq: { kind: :int, required: true },
+          name: { kind: :str, required: true },
+          data: { kind: :json, required: true }
+        }.freeze,
+        "State" => {
+          seq: { kind: :int, required: true },
+          agent: { kind: :str, required: true },
+          call: { kind: :str, null: true, required: true },
+          status: { kind: :ref, ref: "CallStatus", required: true },
+          channel: { kind: :ref, null: true, ref: "Channel", required: true },
+          direction: { kind: :ref, null: true, ref: "Direction", required: true },
+          from: { kind: :str, null: true, required: true },
+          to: { kind: :str, null: true, required: true },
+          caller: { kind: :ref, null: true, ref: "Contact", required: true },
+          room: { kind: :ref, null: true, ref: "Room", required: true },
+          started_at: { kind: :float, null: true, required: true },
+          ended_at: { kind: :float, null: true, required: true },
+          end_reason: { kind: :ref, null: true, ref: "EndReason", required: true },
+          outcome: { kind: :str, null: true, required: true },
+          user_state: { kind: :ref, null: true, ref: "UserState", required: true },
+          agent_state: { kind: :ref, null: true, ref: "AgentState", required: true },
+          live: { kind: :ref, ref: "LiveTranscript", required: true },
+          turns: { kind: :list, items: { kind: :ref, ref: "Turn" }, required: true },
+          metrics: { kind: :ref, ref: "CollectedMetrics", required: true },
+          tools: { kind: :list, items: { kind: :ref, ref: "ToolRun" }, required: true },
+          app_state: { kind: :json, required: true },
+          events: { kind: :list, items: { kind: :ref, ref: "ReceivedEvent" }, required: true },
+          prompt: { kind: :ref, ref: "PromptState", required: true },
+          tools_visible: { kind: :list, items: { kind: :str }, required: true },
+          confirms: { kind: :list, items: { kind: :ref, ref: "Confirm" }, required: true },
+          memory: { kind: :list, items: { kind: :ref, ref: "MemoryOp" }, required: true },
+          sources: { kind: :list, items: { kind: :ref, ref: "DocSource" }, required: true },
+          handoff: { kind: :ref, ref: "Handoff", required: true },
+          held: { kind: :bool, required: true },
+          muted: { kind: :bool, required: true },
+          transfer: { kind: :ref, null: true, ref: "TransferState", required: true },
+          attention: { kind: :ref, null: true, ref: "AttentionState" },
+          usage: { kind: :list, items: { kind: :ref, ref: "ModelUsage" }, required: true },
+          cost: { kind: :ref, null: true, ref: "Cost", required: true },
+          routes: { kind: :list, items: { kind: :ref, ref: "Route" }, required: true },
+          gaps: { kind: :list, items: { kind: :ref, ref: "Gap" }, required: true },
+          errors: { kind: :list, items: { kind: :ref, ref: "LoggedError" }, required: true },
+          custom: { kind: :list, items: { kind: :ref, ref: "CustomNote" }, required: true }
+        }.freeze,
+        "SayVerb" => {
+          verb: { kind: :const, const: "say", required: true },
+          text: { kind: :str, required: true }
+        }.freeze,
+        "WhisperVerb" => {
+          verb: { kind: :const, const: "whisper", required: true },
+          text: { kind: :str, required: true }
+        }.freeze,
+        "TakeoverVerb" => {
+          verb: { kind: :const, const: "takeover", required: true }
+        }.freeze,
+        "ReleaseVerb" => {
+          verb: { kind: :const, const: "release", required: true }
+        }.freeze,
+        "TransferVerb" => {
+          verb: { kind: :const, const: "transfer", required: true },
+          to: { kind: :str, required: true },
+          mode: { kind: :ref, ref: "TransferMode" }
+        }.freeze,
+        "EndVerb" => {
+          verb: { kind: :const, const: "end", required: true },
+          reason: { kind: :str }
+        }.freeze,
+        "DevRefusal" => {
+          status: { kind: :int, required: true },
+          detail: { kind: :str, required: true }
+        }.freeze,
+        "JudgedBy" => {
+          provider: { kind: :str, null: true, required: true },
+          model: { kind: :str, null: true, required: true },
+          criteria: { kind: :str, required: true }
+        }.freeze,
+        "Judgment" => {
+          name: { kind: :str, required: true },
+          verdict: { kind: :ref, ref: "ScoreVerdict", required: true },
+          criteria: { kind: :str, required: true },
+          reason: { kind: :str, required: true },
+          evidence: { kind: :ref, ref: "JudgmentEvidence", required: true }
+        }.freeze,
+        "JudgmentEvidence" => {
+          seqs: { kind: :list, items: { kind: :int }, required: true },
+          said: { kind: :str }
+        }.freeze,
+        "StateCauseTool" => {
+          kind: { kind: :const, const: "tool", required: true },
+          tool: { kind: :str, required: true },
+          call_id: { kind: :str, required: true }
+        }.freeze,
+        "StateCauseEvent" => {
+          kind: { kind: :const, const: "event", required: true },
+          name: { kind: :str, required: true },
+          seq: { kind: :int, required: true }
+        }.freeze,
+      }.freeze
+    end
+  end
+end

data/lib/pinecall/wire/state.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# The state an empty log starts from, and the parts a fold writes into it.
+
+module Pinecall
+  module Wire
+    # The state a log reduces to.
+    module State
+      module_function
+
+      # The state of an empty log. Identical in all three languages, so one log reduces the same.
+      def initial
+        {
+          seq: 0,
+          agent: "",
+          call: nil,
+          status: "idle",
+          channel: nil,
+          direction: nil,
+          from: nil,
+          to: nil,
+          caller: nil,
+          room: nil,
+          started_at: nil,
+          ended_at: nil,
+          end_reason: nil,
+          outcome: nil,
+          user_state: nil,
+          agent_state: nil,
+          live: { user: nil, agent: nil },
+          turns: [],
+          metrics: { llm: [], stt: [], tts: [], vad: [], eou: [], eot: [], interruption: [], realtime: [], avatar: [] },
+          tools: [],
+          app_state: {},
+          events: [],
+          prompt: {},
+          tools_visible: [],
+          confirms: [],
+          memory: [],
+          sources: [],
+          handoff: { active: false, by: nil },
+          held: false,
+          muted: false,
+          transfer: nil,
+          attention: nil,
+          usage: [],
+          cost: nil,
+          routes: [],
+          gaps: [],
+          errors: [],
+          custom: []
+        }
+      end
+    end
+  end
+end

data/lib/pinecall/wire/validate.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Checks a value against a named shape of the table, field by field, refusing a key nobody declared.
+
+module Pinecall
+  module Wire
+    # Validates a payload against the generated shape tables and names the offending field.
+    # The Ruby counterpart of zod and pydantic; a table walk avoids a schema-library dependency.
+    module Validate
+      module_function
+
+      # Validate a payload against the named shape and return it. Shapes are closed: an undeclared
+      # key (e.g. from a newer protocol) is refused rather than silently dropped.
+      def call!(name, value, where: name)
+        return union!(name, value, where) if Shapes::UNIONS.key?(name)
+        return map!(Shapes::MAPS.fetch(name), value, where) if Shapes::MAPS.key?(name)
+
+        shape = Shapes::SHAPES[name]
+        raise WireError, "#{where}: the protocol declares no shape called #{name}" if shape.nil?
+        raise WireError, "#{where}: expected the fields of #{name}, got #{named(value)}" unless value.is_a?(Hash)
+
+        unknown = value.keys - shape.keys
+        raise WireError, "#{where}: #{name} has no field called #{unknown.join(", ")}" unless unknown.empty?
+
+        shape.each { |field, spec| field_of!(shape: name, spec:, value:, field:, where:) }
+        value
+      end
+
+      # One field. An optional one may be absent or null, as TypeScript's nullish reads it: the
+      # runtime writes null for a field it set to nothing.
+      def field_of!(shape:, spec:, value:, field:, where:)
+        return if !spec[:required] && value[field].nil?
+        raise WireError, "#{where}.#{field}: #{shape} requires it" unless value.key?(field)
+
+        field!(spec, value[field], "#{where}.#{field}")
+      end
+
+      # One value against a field descriptor; one branch per kind the generator emits.
+      def field!(spec, value, where)
+        if value.nil?
+          return if spec[:null]
+
+          raise WireError, "#{where}: nothing is not one of the things it may be"
+        end
+
+        case spec[:kind]
+        when :str then string!(spec, value, where)
+        when :int then expect(value, Integer, where, "a whole number")
+        when :float then expect(value, Numeric, where, "a number")
+        when :bool then expect_boolean(value, where)
+        when :json then expect(value, Hash, where, "an object")
+        when :any then value
+        when :list then list!(spec, value, where)
+        when :tuple then tuple!(spec, value, where)
+        when :map then map!(spec[:items], value, where)
+        when :enum then one_of!(spec[:values], value, where)
+        when :const then const!(spec[:const], value, where)
+        when :ref then ref!(spec[:ref], value, where)
+        else raise WireError, "#{where}: the generator emitted a kind nobody reads: #{spec[:kind]}"
+        end
+      end
+
+      # A union is told apart by the one field the schema's discriminator names.
+      def union!(name, value, where)
+        union = Shapes::UNIONS.fetch(name)
+        on = union[:on]
+        said = value.is_a?(Hash) ? value[on] : nil
+        member = union[:members].find { |one| Shapes::SHAPES.dig(one, on, :const) == said }
+        if member.nil?
+          allowed = union[:members].filter_map { |one| Shapes::SHAPES.dig(one, on, :const) }
+          raise WireError, "#{where}: #{on} #{said.inspect} is not one of #{allowed.join(", ")}"
+        end
+        call!(member, value, where:)
+      end
+
+      # A reference points at another object, at a union, or at one of the closed lists.
+      def ref!(name, value, where)
+        allowed = Enums::ALL[name]
+        return one_of!(allowed, value, where) unless allowed.nil?
+
+        call!(name, value, where:)
+      end
+
+      def list!(spec, value, where)
+        expect(value, Array, where, "a list")
+        value.each_with_index { |item, at| field!(spec[:items], item, "#{where}[#{at}]") }
+      end
+
+      # A tuple has a fixed length and one shape per position, e.g. a transcript line [who, what].
+      def tuple!(spec, value, where)
+        expect(value, Array, where, "a list")
+        places = spec[:members]
+        unless value.length == places.length
+          raise WireError, "#{where}: a list of #{places.length} things, not #{value.length}"
+        end
+
+        places.each_with_index { |place, at| field!(place, value[at], "#{where}[#{at}]") }
+      end
+
+      # Map keys are app-chosen names; every value has the same shape.
+      def map!(spec, value, where)
+        expect(value, Hash, where, "an object")
+        value.each { |key, item| field!(spec, item, "#{where}.#{key}") }
+      end
+
+      # JSON Schema's ^ and $ anchor the whole string but Ruby's anchor a line, so a value with a
+      # newline is refused before matching.
+      def string!(spec, value, where)
+        expect(value, String, where, "a string")
+        pattern = spec[:pattern]
+        return value if pattern.nil? || (!value.include?("\n") && Regexp.new(pattern).match?(value))
+
+        raise WireError, "#{where}: #{value.inspect} does not match #{pattern}"
+      end
+
+      def one_of!(values, value, where)
+        return value if values.include?(value)
+
+        raise WireError, "#{where}: #{value.inspect} is not one of #{values.join(", ")}"
+      end
+
+      def const!(const, value, where)
+        return value if value == const
+
+        raise WireError, "#{where}: this field is always #{const.inspect}, never #{value.inspect}"
+      end
+
+      def expect(value, type, where, called)
+        return value if value.is_a?(type)
+
+        raise WireError, "#{where}: expected #{called}, got #{named(value)}"
+      end
+
+      def expect_boolean(value, where)
+        return value if value == true || value == false
+
+        raise WireError, "#{where}: expected true or false, got #{named(value)}"
+      end
+
+      # Describe a value's type in the words the error messages use.
+      def named(value)
+        case value
+        when nil then "nothing"
+        when String then "a string"
+        when Integer, Float then "a number"
+        when true, false then "true or false"
+        when Array then "a list"
+        when Hash then "an object"
+        else value.class.name
+        end
+      end
+    end
+  end
+end

data/lib/pinecall/wire.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# The runtime's wire as this gem speaks it: the shapes, a validator, the codec and the reducer.
+
+require "json"
+require "set"
+
+require_relative "wire/errors"
+require_relative "wire/enums"
+require_relative "wire/shapes"
+require_relative "wire/registry"
+require_relative "wire/validate"
+require_relative "wire/codec"
+require_relative "wire/state"
+require_relative "wire/reduce"
+
+module Pinecall
+  # The wire between gateway and app: events the gateway writes, commands the app sends.
+  module Wire
+    class << self
+      # One log line from parsed JSON.
+      def decode_entry(raw) = Codec.decode_entry(raw)
+
+      # The entry's data as the shape its type names.
+      def event_of(entry) = Codec.event_of(entry)
+
+      # One command frame, checked against the shape its type names.
+      def command(...) = Codec.command(...)
+
+      # A frame as JSON text.
+      def encode(frame) = Codec.encode(frame)
+
+      # Fold a log into the state it means.
+      def reduce(entries) = Reduce.reduce(entries)
+
+      # One entry folded into a state, for a reader following a log as it happens.
+      def apply(state, entry) = Reduce.apply(state, entry)
+
+      # The state of an empty log.
+      def initial_state = State.initial
+    end
+  end
+end

data/lib/pinecall.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Pinecall's Ruby SDK: write an agent as a class and serve its calls over the gateway socket.
+#
+# `Pinecall::Agent` and `Pinecall.mount` are the framework; `Pinecall::Client` is the bare socket
+# for applications that decide their own answers.
+
+require "json"
+require "pinecall/wire"
+
+require_relative "pinecall/version"
+require_relative "pinecall/errors"
+require_relative "pinecall/reading"
+require_relative "pinecall/view"
+require_relative "pinecall/rules"
+require_relative "pinecall/blocks"
+require_relative "pinecall/panel"
+require_relative "pinecall/agent"
+require_relative "pinecall/call_world"
+require_relative "pinecall/client"
+require_relative "pinecall/bridge"
+require_relative "pinecall/serve"
+
+module Pinecall
+  class << self
+    # Mount an agent class on a client; each call gets its own instance. Nothing is sent until
+    # `connect`.
+    def mount(klass, client:, **options) = Bridge.mount(klass, client:, **options)
+
+    # Render the agent's prompt blocks in send order, offline.
+    def render(agent, **context) = Prompt.render(agent, **context)
+
+    # Render the prompt as one page, each block under its header.
+    def show_prompt(agent, **context) = Prompt.show(agent, **context)
+
+    # Serve an agent class from inside your own Ruby process: mounted on a client of its own (or
+    # the one given), connected, and held. `held.stop` drains then closes, for an `at_exit`.
+    def serve(klass, client: nil, url: nil, api_key: nil, env: nil, slug: nil, last: nil)
+      client ||= Client.new(url:, api_key:, env:)
+      mounted = mount(klass, client:, slug: slug || klass.slug, last:)
+      client.connect
+      Serve::Held.new(client, [mounted])
+    end
+  end
+end