sai-sdk 0.1.0

data/lib/sai/sessions.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Sai
+  # Sessions: a conversation with Sai on one computer. Sai decides every click.
+  class Sessions
+    # @api private
+    def initialize(http, machines)
+      @http = http
+      @machines = machines
+    end
+
+    # Start a fresh conversation on a computer: the next message has no memory of earlier ones.
+    # +machine+ (a Machine or its id) may be left out with one computer.
+    # @return [Session]
+    def create(machine: nil)
+      machine_id = resolve_machine(machine)
+      session_id = nil
+      begin
+        d = @http.json("POST", "/v1/agents/new-session", json: { "machineId" => machine_id, "channel" => "api" })
+        session_id = Parse.str(Parse.obj(d)["sessionId"])
+      rescue NotFoundError
+        # A free account's computer between claims has no conversation to rotate; the first
+        # message starts one.
+      end
+      Session.new(@http, machine_id, session_id)
+    end
+
+    # The caller's sessions on a computer (desktop, CLI and API), most recent first (up to 20).
+    # +active+ marks the API channel's current one, which the next message without a session goes to.
+    # @return [Array<SessionSummary>]
+    def list(machine: nil)
+      machine_id = resolve_machine(machine)
+      d = @http.json("GET", "/v1/agents/sessions", params: { "machineId" => machine_id, "channel" => "api" })
+      Parse.list(Parse.obj(d)["sessions"]).map { |s| SessionSummary.parse(s) }
+    end
+
+    # Reattach to a session started elsewhere, e.g. to poll or abort it. Makes no request.
+    # @return [Session]
+    def resume(session_id, machine: nil)
+      Session.new(@http, machine ? Util.id_of(machine) : nil, session_id)
+    end
+
+    private
+
+    def resolve_machine(machine)
+      return Util.id_of(machine) if machine
+
+      machines = @machines.list
+      return machines[0].id if machines.length == 1
+
+      if machines.empty?
+        raise BadRequestError.new("No computer on this account. Create one in the Sai app or the portal.",
+                                  status: 400)
+      end
+      names = machines.map { |m| m.name ? "#{m.id} (#{m.name})" : m.id }.join(", ")
+      raise BadRequestError.new("Several computers on this account; pass machine. Candidates: #{names}",
+                                status: 400)
+    end
+  end
+
+  # A conversation with Sai. Each +send+ is a turn; turns share context.
+  class Session
+    attr_accessor :id, :machine_id
+
+    # @api private
+    def initialize(http, machine_id, id)
+      @http = http
+      @machine_id = machine_id
+      @id = id
+    end
+
+    # Give Sai a task, or steer the running one. Returns a Turn at once. Sent while a turn is
+    # running, the message steers that turn (+turn.queued+ is true).
+    #
+    # Any of +inputs+, +output_schema+ or +success_criteria+ (a string, or a list of Check) makes
+    # the message structured: +wait+ then also returns the turn's record in +result.record+. A
+    # structured message, +record_trajectory+ and +thinking_level+ (+off+, +low+, +medium+,
+    # +high+, +xhigh+) are refused with ConflictError (+session_busy+) while a turn is running.
+    # The same +idempotency_key+ again returns the earlier turn and sends nothing. +autonomous+
+    # runs the turn without approval cards, as if "Trust for this task" had been answered.
+    # @return [Turn]
+    def send(message, model: nil, attachments: nil, inputs: nil, output_schema: nil, success_criteria: nil,
+             idempotency_key: nil, record_trajectory: false, thinking_level: nil, autonomous: false)
+      body = { "message" => message, "wait" => false }
+      body["machineId"] = machine_id if machine_id && !machine_id.empty?
+      body["sessionId"] = id if id && !id.empty?
+      body["model"] = model if model && !model.empty?
+      body["attachments"] = attachments.map(&:raw) if attachments && !attachments.empty?
+      body["autonomous"] = true if autonomous
+      options = {}
+      options["inputs"] = inputs unless inputs.nil?
+      options["output_schema"] = output_schema unless output_schema.nil?
+      options["success_criteria"] = Check.list_to_api(success_criteria) unless success_criteria.nil?
+      options["idempotency_key"] = idempotency_key unless idempotency_key.nil?
+      options["recordTrajectory"] = true if record_trajectory
+      options["thinkingLevel"] = thinking_level unless thinking_level.nil?
+      body["options"] = options unless options.empty?
+      structured = [inputs, output_schema, success_criteria].any? { |v| !v.nil? }
+      d = Parse.obj(@http.json("POST", "/v1/agents/message", json: body))
+      if Parse.truthy(d["idempotent_replay"])
+        # The key was used before: this is that turn, and nothing was sent.
+        record = TurnRecord.parse(d)
+        self.id = record.session_id || id
+        self.machine_id = record.machine_id.empty? ? machine_id : record.machine_id
+        return Turn.new(self, @http, queued: false, id: record.id, structured: structured, replay: record)
+      end
+      session_id = Parse.str(d["sessionId"])
+      if session_id.nil? || session_id.empty?
+        # Handled without starting a task (e.g. a plain acknowledgement): the reply is in reply,
+        # or in error on servers before reply existed.
+        text = Parse.str(d["reply"]) || Parse.str(d["error"]) || ""
+        return Turn.new(self, @http, queued: false, done: Turns.local_result(id || "", text))
+      end
+      self.id = session_id
+      self.machine_id = d["machineId"] if d["machineId"].is_a?(String)
+      Turn.new(self, @http, queued: Parse.truthy(d["queued"]), id: Parse.str(d["turnId"]), structured: structured)
+    end
+
+    # +send+ then +wait+: the answer, or where it stopped. Takes +send+'s options, plus
+    # +on_approval:+ (or a block) and +timeout:+ and +poll_wait:+ as in Turn#wait.
+    # @return [TurnResult]
+    def run(message, on_approval: nil, timeout: nil, poll_wait: nil, **send_options, &block)
+      send(message, **send_options).wait(on_approval: on_approval, timeout: timeout, poll_wait: poll_wait, &block)
+    end
+
+    # Stop the running turn. Pending approvals are denied.
+    # @return [Boolean] false if nothing was running
+    def abort
+      return false if id.nil? || id.empty?
+
+      d = @http.json("POST", "/v1/agents/abort", json: { "sessionId" => id })
+      Parse.truthy(Parse.obj(d)["aborted"])
+    end
+
+    # Answer an approval (an Approval or its id): +yes+, +no+, or +task+ (allow for the rest of
+    # the task). A +choice+ approval needs +selections+, one list of option values per question.
+    # Raises LinkOnlyApprovalError (with +approval_url+) when only a browser can answer it.
+    # @return [String] +approved+, +approved_task+ or +denied+
+    def respond(approval, response = "yes", selections: nil)
+      if approval.is_a?(Approval) && approval.is_link_only
+        raise LinkOnlyApprovalError.new("This approval must be completed in a browser. Open approval.url.",
+                                        status: 409, code: "link_only", body: { "approvalUrl" => approval.url })
+      end
+      body = { "approvalId" => approval.is_a?(Approval) ? approval.id : approval, "response" => response }
+      body["selections"] = selections unless selections.nil?
+      d = @http.json("POST", "/v1/agents/approve", json: body)
+      Parse.str(Parse.obj(d)["status"]) || ""
+    end
+
+    def inspect
+      "#<Sai::Session id=#{id.inspect} machine_id=#{machine_id.inspect}>"
+    end
+  end
+
+  # One message's work. Iterate +events+ to watch it, or +wait+ for the result. +id+ is the turn
+  # the message started, or the running turn it joined; nil when the message was answered
+  # without one.
+  class Turn
+    POLL_WAIT = 30
+    # Turns that failed for these reasons still have the agent's answer.
+    ANSWERED_REASONS = %w[output_invalid criteria_not_met criteria_unchecked].freeze
+    private_constant :ANSWERED_REASONS
+
+    attr_reader :id, :queued, :session
+
+    # @api private
+    def initialize(session, http, queued:, done: nil, id: nil, structured: false, replay: nil)
+      @session = session
+      @http = http
+      @queued = queued
+      @last = done
+      @id = id
+      @structured = structured
+      @replay = replay
+      @cursor = nil
+      # answered without starting a task, or an idempotent replay: no events to poll
+      @local = !done.nil? || !replay.nil?
+    end
+
+    # +running+ until a poll says otherwise; see TURN_STATUSES.
+    def status
+      @last ? @last.status : "running"
+    end
+
+    # The last known state, or nil before the first poll.
+    # @return [TurnResult, nil]
+    def result
+      @last
+    end
+
+    # Yield events until the turn is idle or errors, through +needs_approval+: answer with
+    # +turn.respond(ev.approval, ...)+ inside the loop. Without +raw+, framing, reasoning and
+    # tool-call frames are skipped. Without a block, returns an Enumerator.
+    # @yieldparam event [Event]
+    def events(raw: false, poll_wait: POLL_WAIT)
+      return enum_for(:events, raw: raw, poll_wait: poll_wait) unless block_given?
+      return if @local
+
+      loop do
+        page = poll(poll_wait)
+        Parse.list(page["events"]).each do |e|
+          ev = Event.parse(Parse.obj(e))
+          yield ev if raw || ev.kind != "other"
+        end
+        break if %w[idle error].include?(page["status"])
+      end
+      nil
+    end
+
+    # Wait until the turn is done, or stops on an approval nobody answered. Without a handler,
+    # returns with +status == "needs_approval"+ and the +approval+. With one (+on_approval:+ or a
+    # block), its answer is sent and waiting continues: a response (+"yes"+, +"no"+, +"task"+),
+    # a +[response, selections]+ pair for a choice, or nil to leave the approval to someone else
+    # and keep waiting. For a structured message it then waits for the turn's record. +timeout+
+    # (seconds) raises Timeout::Error with the turn still running; +poll_wait+ is the seconds the
+    # server may hold one poll (it caps at 60).
+    # @yieldparam approval [Approval]
+    # @return [TurnResult]
+    def wait(on_approval: nil, timeout: nil, poll_wait: nil, &block)
+      handler = on_approval || block
+      deadline = timeout.nil? ? nil : Util.monotonic + timeout
+      if @replay
+        record = @replay.done ? @replay : Turns.wait_record(@http, @replay.id, deadline)
+        @last = replay_result(record, record.session_id || session.id || "")
+        return @last
+      end
+      return @last if @local
+
+      answered = {}
+      loop do
+        wait_s = poll_wait || POLL_WAIT
+        if deadline
+          left = deadline - Util.monotonic
+          raise Timeout::Error, "Turn still #{status} after #{timeout}s (session #{session.id})." if left <= 0
+
+          wait_s = [1, [wait_s, left.floor].min].max
+        end
+        page = poll(wait_s)
+        if %w[idle error].include?(page["status"])
+          @last.record = Turns.wait_record(@http, id, deadline) if @structured && id
+          return @last
+        end
+        approval = @last&.approval
+        next if page["status"] != "needs_approval" || approval.nil?
+        return @last unless handler
+        next if answered[approval.id]
+
+        answer = handler.call(approval)
+        answered[approval.id] = true
+        next if answer.nil?
+
+        response, selections = answer.is_a?(Array) ? answer : [answer, nil]
+        begin
+          session.respond(approval, response, selections: selections)
+        rescue ConflictError
+          # answered elsewhere or expired; the next poll shows the new state
+        end
+      end
+    end
+
+    # Answer an approval; see Session#respond.
+    def respond(approval, response = "yes", selections: nil)
+      session.respond(approval, response, selections: selections)
+    end
+
+    # Stop the running turn; see Session#abort.
+    def abort
+      session.abort
+    end
+
+    def inspect
+      "#<Sai::Turn id=#{id.inspect} queued=#{queued} status=#{status.inspect}>"
+    end
+
+    private
+
+    def poll(wait_s)
+      page = nil
+      loop do
+        params = { "sessionId" => session.id || "", "wait" => wait_s, "since" => @cursor }
+        page = Parse.obj(@http.json("GET", "/v1/agents/events", params: params, timeout: wait_s + 30))
+        break
+      rescue RateLimitError => e
+        sleep(e.retry_after.nil? ? 30 : e.retry_after)
+      end
+      @cursor = Parse.str(page["cursor"]) || @cursor
+      error = @last&.error
+      error_code = @last&.error_code
+      Parse.list(page["events"]).each do |e|
+        next unless e.is_a?(Hash) && e["type"] == "error"
+
+        error = e["errorText"] if e["errorText"].is_a?(String)
+        error_code = e["code"] if e["code"].is_a?(String)
+      end
+      @last = TurnResult.new(
+        status: Parse.str(page["status"]) || "running",
+        text: Parse.str(page["text"]) || "",
+        session_id: Parse.str(page["sessionId"]) || session.id || "",
+        approval: page["approval"].is_a?(Hash) ? Approval.parse(page["approval"]) : nil,
+        error: error,
+        error_code: error_code,
+        usage: Parse.usage(page["usage"]),
+        session_usage: Parse.usage(page["sessionUsage"]),
+        record: nil
+      )
+      page
+    end
+
+    # The result the live path would have returned for this finished turn, from its record.
+    def replay_result(record, session_id)
+      answer = record.raw_answer.nil? || record.raw_answer.empty? ? output_text(record.output) : record.raw_answer
+      result = Turns.local_result(session_id, answer)
+      if record.status == "failed" && !ANSWERED_REASONS.include?(record.reason_code || "")
+        result.status = "error"
+        result.text = ""
+        result.error = record.raw_answer.nil? || record.raw_answer.empty? ? "The turn failed (#{record.reason_code || 'unknown'})." : record.raw_answer
+        result.error_code = record.error_code
+      end
+      result.usage = record.usage
+      result.record = record
+      result
+    end
+
+    # +output+ as text: a plain message's answer as is, an +output_schema+ object as JSON.
+    def output_text(output)
+      return "" if output.nil?
+
+      output.is_a?(String) ? output : JSON.generate(output)
+    end
+  end
+end

data/lib/sai/tenants.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Sai
+  # Tenants: your customers, under an Organisation. Every call takes an Organisation Key. A tenant
+  # argument is a Tenant or its id.
+  class Tenants
+    # +client+ exchanges again when its token has less than this left, in milliseconds.
+    TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
+    UNSET = Object.new.freeze
+    private_constant :UNSET
+
+    # @api private
+    def initialize(http, org_id, with_credential)
+      @http = http
+      @org_id = org_id
+      @with_credential = with_credential
+    end
+
+    # +external_id+ is your id for the customer, unique in the Organisation; it cannot change.
+    # @return [Tenant]
+    def create(name, external_id: nil, metadata: nil)
+      body = { "name" => name }
+      body["externalId"] = external_id unless external_id.nil?
+      body["metadata"] = metadata unless metadata.nil?
+      Tenant.parse(Parse.obj(@http.json("POST", "/v1/tenants", json: body)))
+    end
+
+    # One page, newest first. +external_id+ finds the Tenant with that id (zero or one) and cannot
+    # be combined with +status+.
+    # @return [TenantPage]
+    def list(status: nil, external_id: nil, limit: nil, cursor: nil)
+      params = { "status" => status, "externalId" => external_id, "limit" => limit, "cursor" => cursor }
+      d = Parse.obj(@http.json("GET", "/v1/tenants", params: params))
+      TenantPage.new(tenants: Parse.list(d["tenants"]).map { |t| Tenant.parse(Parse.obj(t)) },
+                     next_cursor: Parse.str(d["nextCursor"]))
+    end
+
+    # @return [Tenant]
+    def get(tenant)
+      Tenant.parse(Parse.obj(@http.json("GET", self.class.path(tenant))))
+    end
+
+    # Sends only what is given. +metadata+ replaces the whole map. +status: "disabled"+ stops the
+    # Tenant's tokens and machines; +"active"+ brings it back. +cloud_machine_limit+ (0 to 1000)
+    # caps the Tenant's cloud machines, and +cloud_machine_limit: nil+ removes the cap.
+    # +residential_proxy+ has no effect yet. Only the Organisation Key or an owner may set these two.
+    # @return [Tenant]
+    def update(tenant, name: nil, metadata: nil, status: nil, cloud_machine_limit: UNSET, residential_proxy: nil)
+      body = {}
+      body["name"] = name unless name.nil?
+      body["metadata"] = metadata unless metadata.nil?
+      body["status"] = status unless status.nil?
+      body["cloudMachineLimit"] = cloud_machine_limit unless cloud_machine_limit.equal?(UNSET)
+      body["residentialProxy"] = residential_proxy unless residential_proxy.nil?
+      Tenant.parse(Parse.obj(@http.json("PATCH", self.class.path(tenant), json: body)))
+    end
+
+    # Disables the Tenant and revokes every enrolled machine. Cloud machines stay and hibernate:
+    # delete them with +tenant_machines.delete+.
+    # @return [nil]
+    def delete(tenant)
+      @http.request("DELETE", self.class.path(tenant))
+      nil
+    end
+
+    # A single-use code that enrolls one computer into the Tenant. It expires in 15 minutes.
+    # @return [Enrollment]
+    def create_enrollment(tenant)
+      Enrollment.parse(Parse.obj(@http.json("POST", "#{self.class.path(tenant)}/enrollments")))
+    end
+
+    # Exchange the Organisation Key for a one-hour token that acts as the Tenant. +org_id+
+    # defaults to the client's (+SAI_ORG_ID+).
+    # @return [TenantToken]
+    def token(tenant, org_id: nil)
+      org = org_id || @org_id
+      raise ArgumentError, "No Organisation id: pass org_id: here or to Sai::Client.new, or set SAI_ORG_ID." if org.nil? || org.empty?
+
+      path = "/v1/orgs/#{Util.q(org)}/tenants/#{Util.q(Util.id_of(tenant))}/token"
+      TenantToken.parse(Parse.obj(@http.json("POST", path)))
+    end
+
+    # A client that acts as the Tenant. It exchanges a token now, and again before a request when
+    # the token has less than five minutes left, with this client's Organisation Key.
+    # @return [Client]
+    def client(tenant, org_id: nil)
+      current = token(tenant, org_id: org_id)
+      lock = Mutex.new
+      @with_credential.call(lambda do
+        lock.synchronize do
+          current = token(tenant, org_id: org_id) if current.expires_at - Util.now_ms < TOKEN_REFRESH_MARGIN_MS
+          current.token
+        end
+      end)
+    end
+
+    # @api private
+    def self.path(tenant)
+      "/v1/tenants/#{Util.q(Util.id_of(tenant))}"
+    end
+  end
+
+  # A Tenant's computers, enrolled and cloud. Every call takes an Organisation Key.
+  class TenantMachines
+    # Between machine reads while +create(wait: true)+ waits.
+    POLL_INTERVAL = 5
+
+    # @api private
+    def initialize(http)
+      @http = http
+    end
+
+    # Create a cloud machine for the Tenant. +os+ is +windows+ or +linux+. +name+ (up to 64
+    # characters) is a label you show your users. The same +request_id+ makes a retry safe.
+    #
+    # Returns at once with +state == "provisioning"+. +wait: true+ reads the machine until it is
+    # +ready+; it raises Error (with the machine as +body+) if the machine fails or is deleted,
+    # and Timeout::Error after +timeout+ seconds.
+    # @return [TenantMachine]
+    def create(tenant, os:, name: nil, request_id: nil, wait: false, timeout: 600)
+      body = { "os" => os }
+      body["name"] = name unless name.nil?
+      body["requestId"] = request_id unless request_id.nil?
+      machine = TenantMachine.parse(Parse.obj(@http.json("POST", "#{Tenants.path(tenant)}/machines", json: body)))
+      return machine unless wait
+
+      deadline = Util.monotonic + timeout
+      while machine.state != "ready"
+        if %w[failed deleting].include?(machine.state)
+          raise Error.new("Cloud machine #{machine.id} is #{machine.state} and will not become ready.",
+                          body: machine.raw)
+        end
+        raise Timeout::Error, "Cloud machine #{machine.id} still #{machine.state}." if Util.monotonic + POLL_INTERVAL > deadline
+
+        sleep(POLL_INTERVAL)
+        begin
+          machine = get(tenant, machine.id)
+        rescue RateLimitError => e
+          sleep(e.retry_after.nil? ? 30 : e.retry_after)
+        end
+      end
+      machine
+    end
+
+    # Both kinds, enrolled and cloud.
+    # @return [Array<TenantMachine>]
+    def list(tenant)
+      d = Parse.obj(@http.json("GET", "#{Tenants.path(tenant)}/machines"))
+      Parse.list(d["machines"]).map { |m| TenantMachine.parse(Parse.obj(m)) }
+    end
+
+    # @return [TenantMachine]
+    def get(tenant, machine_id)
+      TenantMachine.parse(Parse.obj(@http.json("GET", "#{Tenants.path(tenant)}/machines/#{Util.q(machine_id)}")))
+    end
+
+    # An enrolled machine is signed out at once (+"revoked"+). A cloud machine is deleted with its
+    # disk (+"deleting"+), which cannot be undone.
+    # @return [String] +"revoked"+ or +"deleting"+
+    def delete(tenant, machine)
+      res = @http.request("DELETE", "#{Tenants.path(tenant)}/machines/#{Util.q(Util.id_of(machine))}")
+      res.status == 202 ? "deleting" : "revoked"
+    end
+
+    # +delete+ without its answer. On a cloud machine it deletes the machine: use +delete+.
+    # @return [nil]
+    def revoke(tenant, machine)
+      delete(tenant, machine)
+      nil
+    end
+  end
+end

data/lib/sai/turns.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Sai
+  # Turns: what a message to Sai started or joined. Every message gets a turn id (+turn.id+); this
+  # reads the turn's record: status, output, evidence, usage, and its trajectory when the message
+  # set +record_trajectory+. Each method takes a Turn, a TurnRecord or the id string.
+  class Turns
+    # Between turn reads; +GET /v1/agents/turns/{id}+ never holds.
+    RECORD_POLL_INTERVAL = 2
+
+    # @api private
+    def initialize(http)
+      @http = http
+    end
+
+    # The turn's record now. Never waits: +finalizing+ while the result is worked out.
+    # @return [TurnRecord]
+    def get(turn)
+      TurnRecord.parse(Parse.obj(@http.json("GET", "/v1/agents/turns/#{Util.q(Util.turn_id(turn))}")))
+    end
+
+    # Read the turn until it is +succeeded+, +failed+ or +needs_input+. On +needs_input+, answer
+    # the approval on the turn's session (+sai.sessions.resume(record.session_id)+) and wait
+    # again. +timeout+ (seconds) raises Timeout::Error with the turn unfinished.
+    # @return [TurnRecord]
+    def wait(turn, timeout: nil)
+      deadline = timeout.nil? ? nil : Util.monotonic + timeout
+      self.class.wait_record(@http, Util.turn_id(turn), deadline, %w[succeeded failed needs_input])
+    end
+
+    # The steps the agent took, in order. Recorded only when the message set +record_trajectory+.
+    # @return [Array<TrajectoryStep>]
+    def trajectory(turn)
+      d = Parse.obj(@http.json("GET", "/v1/agents/turns/#{Util.q(Util.turn_id(turn))}/trajectory"))
+      Parse.list(d["steps"]).map { |s| TrajectoryStep.parse(Parse.obj(s)) }
+    end
+
+    # The screen before step +index+ (the last one is after the turn), as JPEG bytes.
+    # @return [String] a binary String
+    def screenshot(turn, index)
+      @http.request("GET", "/v1/agents/turns/#{Util.q(Util.turn_id(turn))}/trajectory/screenshots/#{index}").body
+    end
+
+    # @api private
+    # Read the turn's record until its status is in +stop+. Raises Timeout::Error past +deadline+
+    # (a monotonic time).
+    def self.wait_record(http, turn_id, deadline, stop = %w[succeeded failed])
+      loop do
+        begin
+          record = TurnRecord.parse(Parse.obj(http.json("GET", "/v1/agents/turns/#{Util.q(turn_id)}")))
+        rescue RateLimitError => e
+          sleep(e.retry_after.nil? ? 30 : e.retry_after)
+          next
+        end
+        return record if stop.include?(record.status)
+        if deadline && Util.monotonic + RECORD_POLL_INTERVAL > deadline
+          raise Timeout::Error, "Turn #{turn_id} still #{record.status}."
+        end
+
+        sleep(RECORD_POLL_INTERVAL)
+      end
+    end
+
+    # @api private
+    def self.local_result(session_id, text)
+      TurnResult.new(status: "idle", text: text, session_id: session_id, approval: nil, error: nil,
+                     error_code: nil, usage: nil, session_usage: nil, record: nil)
+    end
+  end
+end