withruntime 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92aca2f2d4a8d94b0871172606a8608e07d916e2e7236adab4b5752409fb466e
-  data.tar.gz: 87b4a3b19035d177f07c5a98b5adf256e7eab48769c1f803850d10b552800f64
+  metadata.gz: 1c1a17e5090c78b095eebfac78fff07cbd5222b14ba973cc71c619fec9ed4722
+  data.tar.gz: ee609373f8a0c8dbfb12ede50c25930647456031fef41576d411a60e5743dfbb
 SHA512:
-  metadata.gz: 28866196e471465715beba471c141ae01a1de33f5b4fc66266a53dc5fc27f170c1d0f67920bbeff930ee4bcaf00a574768e4800d71b292b8cbe88426cca049c8
-  data.tar.gz: e1339ba49b930b10c79f043d5187906dfff71c0a2832f7dc5569b2cd0b5a62b1544f6b312ca9944d9bc384d7718eab8cfb32f11a8642e3782d29d06e6c96aee5
+  metadata.gz: f4ecd87a36108a2a1856e9e0051d010bdeae9393e5ada0681264d6bf81758afdabd33b3f4148e08a08ca94eb5018d718c2601bbf9f2cc1b7972a4b95886534d2
+  data.tar.gz: 555018e2954343260c2f88f6661d800ce8ecbd482f91acfdfe7c5f2e9b96ecd8880dfb2a16ace2c65264fd9d3311a361f398ab3637a257effd1d521e74b0062b

data/lib/withruntime/agents.rb

@@ -65,7 +65,10 @@ module WithRuntime
   # /workspace/repo), +vcpu+ and +memory_mib+ (4 vCPU and 8 GiB unless set; a
   # definition from a snapshot takes neither, InvalidRequestError, since a
   # snapshot keeps its own size), +instructions+, +env+, +secrets+ (names of
-  # egress secrets: model keys go here), +mcp+ ([{ name:, url: }]), +volumes+
+  # egress secrets: model keys go here), +pool+ (1 to 16 Claude accounts,
+  # each an egress secret's name: each session takes the one with the most
+  # usage left, and the review template moves to the next when one is out
+  # of usage), +mcp+ ([{ name:, url: }]), +volumes+
   # ([{ volume:, path: }]), +idle_pause_seconds+, +max_session_seconds+,
   # +max_concurrent+, +max_session_dollars+ (more than 0, at most 10000, 5
   # unless set: the session and every session under it, the root's covering
@@ -75,7 +78,7 @@ module WithRuntime
   # (402), until the next day) and +template+ ("support" or
   # "team").
   class Agents < Product
-    attr_reader :sessions, :triggers, :templates, :memory
+    attr_reader :sessions, :triggers, :templates, :memory, :asks
 
     def initialize(transport)
       super
@@ -83,7 +86,7 @@ module WithRuntime
       @triggers = AgentTriggers.new(transport)
       @templates = AgentTemplates.new
       @memory = AgentMemory.new(transport)
-      # Approvals come later, here: agents.approvals.list / answer.
+      @asks = AgentAsks.new(transport)
     end
 
     # Makes an agent at version 1. A name already used is a ConflictError
@@ -297,20 +300,105 @@ module WithRuntime
   #
   # A slack or github trigger whose app is not installed for the account is
   # refused +not_installed+ (ConflictError).
+  #
+  # Each trigger has +rules+, every one optional: +priority+ (-100 to 100:
+  # queue order when the agent's maxConcurrent is full, higher first),
+  # +max_starts_per_hour+ (a call past it is held for you), +on_ended+
+  # ("start", "note" or "ask": what a call does when its key's session has
+  # ended), +notify+ ("email" or "webhook": where a held call is told) and,
+  # a webhook's only, +key+ ("{cause}": the key of a call that sends none,
+  # from its JSON's fields). A call no session can take is held, never
+  # dropped: +held+, +start_held+, +dismiss_held+.
   class AgentTriggers < Product
-    def create(agent, kind, config = {})
-      Record.new(@t.json("POST", "/v1/agents/#{seg(agent)}/triggers", body: { "kind" => kind, "config" => Fields.convert(config.to_h) }))
+    def create(agent, kind, config = {}, rules: nil)
+      body = { "kind" => kind, "config" => Fields.convert(config.to_h) }
+      body["rules"] = Fields.convert(rules.to_h) if rules
+      Record.new(@t.json("POST", "/v1/agents/#{seg(agent)}/triggers", body: body))
+    end
+
+    # Its rules, whole, in place: its secret stays. +{}+ is every default.
+    def set_rules(id, rules)
+      Record.new(@t.json("PATCH", "/v1/agents/triggers/#{seg(id)}", body: { "rules" => Fields.convert(rules.to_h) }))
+    end
+
+    # Calls a webhook trigger as its sender would, by its +secret+, never your
+    # key: +outcome+ started, joined (the open session with +key+), noted or
+    # held, with +session_id+, +seq+, +call_id+ and +why+. The same
+    # +idempotency_key+ is the same call.
+    def call(id, secret, text, key: nil, labels: nil, idempotency_key: nil)
+      body = Fields.body(text: text, key: key, labels: labels)
+      Record.new(@t.json("POST", "/v1/agents/triggers/#{seg(id)}/calls", body: body, bearer: secret,
+                                                                          key: idempotency_key))
+    end
+
+    # The calls it held for you, newest first; +each+ walks every page.
+    def held(id, state: nil, cursor: nil, limit: nil)
+      held_page(id, { "state" => state, "limit" => limit }, cursor)
+    end
+
+    # Starts a held call: one session with it and every call held for its key
+    # since, oldest first. +session+, +joined+ and +calls+.
+    def start_held(id, call_id)
+      Record.new(@t.json("POST", "/v1/agents/triggers/#{seg(id)}/held/#{seg(call_id)}/start", body: {}))
+    end
+
+    # Dismisses a held call: nothing runs.
+    def dismiss_held(id, call_id)
+      Record.new(@t.json("POST", "/v1/agents/triggers/#{seg(id)}/held/#{seg(call_id)}/dismiss", body: {}))
     end
 
     def list(agent) = @t.json("GET", "/v1/agents/#{seg(agent)}/triggers")["data"].map { |row| Record.new(row) }
 
-    # Holds this trigger alone; its events are refused +trigger_paused+, with
-    # +why+, where they came from. Nothing else is held.
+    # Holds this trigger alone, saying +why+: a webhook's calls are held for
+    # you (+held+), never dropped. Nothing else is held.
     def pause(id, why) = Record.new(@t.json("POST", "/v1/agents/triggers/#{seg(id)}/pause", body: { "why" => why }))
 
     def resume(id) = Record.new(@t.json("POST", "/v1/agents/triggers/#{seg(id)}/resume", body: {}))
 
     def delete(id) = @t.json("DELETE", "/v1/agents/triggers/#{seg(id)}") && nil
+
+    private
+
+    def held_page(id, query, cursor)
+      body = @t.json("GET", "/v1/agents/triggers/#{seg(id)}/held", query: query.merge("cursor" => cursor))
+      Page.new(body["data"].map { |item| Record.new(item) }, body["nextCursor"]) { |after| held_page(id, query, after) }
+    end
+  end
+
+  # +runtime.agents.asks+: the account's inbox, the questions its agents'
+  # sessions need answered to go on. Each has +why+ it matters, +options+
+  # ({label, detail}), a recommended +pick+ and maybe an expiry. Asks of
+  # one agent's sessions sharing a memory, with the same +step+, are one
+  # row while it is open, and one answer reaches every session asking. +state+: open, answered,
+  # withdrawn, expired (no pick) or closed (every asking session ended).
+  class AgentAsks < Product
+    # The first page, newest first: open asks unless +state+ (one or a list)
+    # says otherwise; of one +agent+; carrying every one of +labels+ (who sees
+    # an ask). +each+ walks every page.
+    def list(state: nil, agent: nil, labels: nil, cursor: nil, limit: nil)
+      label = labels&.map { |k, v| "#{k}:#{v}" }
+      asks_page({ "state" => state, "agent" => agent, "label" => label, "limit" => limit }, cursor)
+    end
+
+    # One ask, with the sessions asking it.
+    def get(id) = Record.new(@t.json("GET", "/v1/agents/asks/#{seg(id)}"))
+
+    # Answers with an +option+'s label, +text+, or both: every session asking
+    # reads it next and wakes. One no longer open is refused +ask_closed+
+    # (ConflictError).
+    def answer(id, option = nil, text: nil, idempotency_key: nil)
+      raise ArgumentError, "an answer is an option's label, text, or both" if option.nil? && text.nil?
+
+      body = Fields.body(option: option, text: text)
+      Record.new(@t.json("POST", "/v1/agents/asks/#{seg(id)}/answer", body: body, key: idempotency_key))
+    end
+
+    private
+
+    def asks_page(query, cursor)
+      body = @t.json("GET", "/v1/agents/asks", query: query.merge("cursor" => cursor))
+      Page.new(body["data"].map { |item| Record.new(item) }, body["nextCursor"]) { |after| asks_page(query, after) }
+    end
   end
 
   # A page of an agent's memory files; +usage+ is the agent's whole memory,
@@ -376,10 +464,11 @@ module WithRuntime
     end
   end
 
-  # +runtime.agents.templates+: the five harnesses an agent can run, each
-  # usable for either use, and the two uses.
+  # +runtime.agents.templates+: the harnesses an agent can run, each usable
+  # for either use, and the two uses. +review+ is a CI/CD agent step's
+  # reviewer, on a +pool+ of Claude accounts.
   #
-  #   runtime.agents.templates.map(&:key)   # claude-code, codex, gemini-cli, claude-agent-sdk, openai-agents-sdk
+  #   runtime.agents.templates.map(&:key)   # claude-code, codex, gemini-cli, claude-agent-sdk, openai-agents-sdk, review, judge
   #   runtime.agents.templates["codex"].api_key_secret
   #   runtime.agents.templates.uses["support"].session_key
   #   runtime.agents.templates.definition("claude-code", use: "support")
@@ -454,6 +543,36 @@ module WithRuntime
             "command" => "python3 ~/agent.py",
             "secrets" => ["OPENAI_API_KEY"]
           }
+        },
+        "review" => {
+          "key" => "review",
+          "title" => "Code review",
+          "command" => "python3 ~/.runtime-agent/runtime-agent review",
+          "apiKeySecret" => "ANTHROPIC_API_KEY",
+          "apiKeyHost" => "api.anthropic.com",
+          "subscription" => "a token per account: run `claude setup-token` on your own computer (Pro/Max) for each, store each with `runtime secrets set CLAUDE_1` scoped to api.anthropic.com, then name them all in pool (--pool CLAUDE_1 --pool CLAUDE_2)",
+          "definition" => {
+            "command" => "python3 ~/.runtime-agent/runtime-agent review",
+            "pool" => ["ANTHROPIC_API_KEY"],
+            "vcpu" => 2,
+            "memoryMiB" => 2048,
+            "maxSessionSeconds" => 1800
+          }
+        },
+        "judge" => {
+          "key" => "judge",
+          "title" => "Your rules",
+          "command" => "python3 ~/.runtime-agent/runtime-agent judge",
+          "apiKeySecret" => "ANTHROPIC_API_KEY",
+          "apiKeyHost" => "api.anthropic.com",
+          "subscription" => "a token per account, as for review: `runtime secrets set CLAUDE_1` scoped to api.anthropic.com for each, then name them all in pool; its instructions are the rules that block",
+          "definition" => {
+            "command" => "python3 ~/.runtime-agent/runtime-agent judge",
+            "pool" => ["ANTHROPIC_API_KEY"],
+            "vcpu" => 2,
+            "memoryMiB" => 2048,
+            "maxSessionSeconds" => 1800
+          }
         }
       },
       "uses" => {

data/lib/withruntime/apps.rb

@@ -158,13 +158,17 @@ module WithRuntime
   # memory_mib, port, health_path, cdn, live_version, previous_version, error
   # ({code, message} or nil), line (while a copy waits for room: lane,
   # place, ahead by lane and words; nil otherwise), created_at, updated_at,
-  # deleted_at, and release_watch (alert, the default; rollback; or off). A Function
-  # also has sleep_after_ms (250 to 5000).
+  # deleted_at, and release_watch (alert, the default; rollback; or off). An App
+  # also has release_stages (at_once, the default, or staged), release_soak_seconds
+  # (60 to 3600) and staged_release (its staged release under way or its last:
+  # version, from, state rolling/back/done/failed/ended, stage, stages, copies,
+  # of, soak_seconds, detail, started_at, updated_at; nil before its first). A
+  # Function also has sleep_after_ms (250 to 5000).
   #
   # A deploy: id, version, url and state (building, warming, switching, live,
   # failed, superseded); a failed or superseded one has error with code
   # (deploy_build_failed, deploy_health_failed, deploy_stop_failed,
-  # deploy_switch_failed, deploy_superseded), message, hint and last_output. A version: version,
+  # deploy_stage_failed, deploy_switch_failed, deploy_superseded), message, hint and last_output. A version: version,
   # live, previous, saved, deploy (its deploy's id) and build (nil for an
   # image). A copy: id, version,
   # region, state (starting, serving, draining, frozen, parked) and since.
@@ -186,7 +190,13 @@ module WithRuntime
     # nothing cached), +name:+, +labels:+, +release_watch:+ ("alert" by default: tell the
     # owners when a new version gets clearly worse in its first 15 minutes; "rollback" also
     # goes back to the previous version; "off" does neither), and for an App
-    # +min_copies:+ (0). A Function leaves +min_copies+ out, zero included.
+    # +min_copies:+ (0). An App also takes +release_stages:+ ("at_once" by default;
+    # "staged" starts one copy of a new version beside the live version's, then
+    # about 10%, 50% and all of them, each stage judged on its visitors' errors
+    # and speed before the next; a stage that does worse goes back, its copies
+    # drain and the deploy fails with deploy_stage_failed, the live version never
+    # stopping) and +release_soak_seconds:+ (60 to 3600, default 300: how long
+    # each stage runs once its copies serve). A Function leaves +min_copies+ out, zero included.
     # A Function also takes +sleep_after_ms:+ (250 to 5000, default 1000): at
     # most how long a copy stays awake after its last request ends; awake time
     # with no request in flight is not billed. An App is refused it.

data/lib/withruntime/ci.rb

@@ -10,7 +10,7 @@ module WithRuntime
   #   job = runtime.ci.checks.get(check.id).jobs.first
   #   puts runtime.ci.jobs.get(job.id).log
   class CI < Product
-    attr_reader :repositories, :checks, :jobs, :tests, :flakes
+    attr_reader :repositories, :checks, :jobs, :tests, :flakes, :releases
 
     def initialize(transport)
       super
@@ -19,13 +19,15 @@ module WithRuntime
       @jobs = CIJobs.new(transport)
       @tests = CITests.new(transport)
       @flakes = CIFlakes.new(transport)
+      @releases = CIReleases.new(transport)
     end
   end
 
   # +runtime.ci.repositories+: the repositories whose checks run.
   #
   # A repository: id, name, labels, repository (owner/name), production_branch,
-  # config_path, installation, github_repository_id, state (connected or
+  # config_path, installation, github_repository_id, undo_culprits (whether a
+  # red production branch's culprit is undone: set_undo), state (connected or
   # disconnected), error, created_at, updated_at and deleted_at.
   class CIRepositories < Product
     # Connects +repository+ ("owner/name"), read through Runtime's GitHub App.
@@ -45,6 +47,15 @@ module WithRuntime
       page("/v1/ci/repositories", { "name" => name, "label" => label, "state" => state, "limit" => limit, "cursor" => cursor })
     end
 
+    # Turns on (or off) the undo of a red production branch's culprit: when
+    # main's check fails, CI/CD finds the first commit that fails it and opens
+    # a pull request reverting it, which lands once its own check passes. Off
+    # until set; only an owner's or admin's full key sets it.
+    def set_undo(id, on, idempotency_key: nil)
+      Record.new(@t.json("POST", "/v1/ci/repositories/#{seg(id)}:update", body: { "undoCulprits" => on },
+                                                                          key: idempotency_key))
+    end
+
     # Stops running its checks; the checks already run stay readable.
     def disconnect(id, idempotency_key: nil)
       Record.new(@t.json("DELETE", "/v1/ci/repositories/#{seg(id)}", key: idempotency_key))
@@ -68,15 +79,24 @@ module WithRuntime
 
     # The check with its +jobs+ in plan order (no log).
     def get(id) = Record.new(@t.json("GET", "/v1/ci/checks/#{seg(id)}"))
+
+    # Cancels a queued or running check: its jobs end and its machines are let
+    # go. A check that has ended is answered as it is.
+    def cancel(id) = Record.new(@t.json("POST", "/v1/ci/checks/#{seg(id)}:cancel"))
+
+    # Runs a check again, as GitHub's Re-run does: a new check of the same
+    # commit, trusted only as the commit's last check was.
+    def rerun(id) = Record.new(@t.json("POST", "/v1/ci/checks/#{seg(id)}:rerun"))
   end
 
   # +runtime.ci.jobs+: one command of a check, run in sandboxes.
   class CIJobs < Product
     # The job with its +log+ (the tail, at most 256 KiB). A failed job's
     # sandbox_ids may be kept paused: wake one or exec in it with
-    # +runtime.sandboxes+. A review step's job has its +review+: the verdict
-    # (pass or block), summary, findings (kind, file, line, what, fix), notes,
-    # and the agent, account, model and session that gave it; nil otherwise.
+    # +runtime.sandboxes+. An agent step's job (+review:+ is its short form)
+    # has its +review+: the verdict (pass or block), summary, findings (kind,
+    # file, line, what, fix), notes, and the agent, the model the step asked
+    # for (nil when none) and the session that gave it; nil otherwise.
     def get(id) = Record.new(@t.json("GET", "/v1/ci/jobs/#{seg(id)}"))
   end
 
@@ -119,4 +139,18 @@ module WithRuntime
       Record.new(@t.json("POST", "/v1/ci/flakes/#{seg(id)}:update", body: body, key: idempotency_key))
     end
   end
+
+  # +runtime.ci.releases+: the steps each release took, as it took them: a
+  # migration's copy test or apply, a deploy ref moved, a server's canary or
+  # release, the website's deploy or promote, or a wait and why. Only
+  # repositories whose releases CI/CD runs have any.
+  #
+  # A step: id, repository_id, commit, source (mover, or the deploy target
+  # that walked it), host (or nil), line and at.
+  class CIReleases < Product
+    # Steps, newest first; +commit:+ keeps one release's.
+    def list(repository_id: nil, commit: nil, limit: nil, cursor: nil)
+      page("/v1/ci/releases", { "repositoryId" => repository_id, "commit" => commit, "limit" => limit, "cursor" => cursor })
+    end
+  end
 end

data/lib/withruntime/client.rb

@@ -96,6 +96,20 @@ module WithRuntime
     # The account's credit, holds, free time and per-resource charges.
     def usage = Record.new(@transport.json("GET", "/v1/usage"))
 
+    # One page of settled usage for every product the key sees: settled at
+    # +since+ or later and before +until+ (UTC, ending in Z). Follow
+    # +next_cursor+ with the same range until it is nil; concatenate each
+    # page's +csv+ (the header is on the first only). Money and quantities are
+    # exact decimal strings. +final_through+: no row settled before it can
+    # still appear or change, so the range is final once it reaches +until+.
+    # A row's +final+ is true once its resource is deleted and can be charged
+    # nothing more.
+    def usage_export(since:, until:, cursor: nil, limit: nil)
+      # until is a Ruby keyword: its argument is read through the binding.
+      query = { "since" => since, "until" => binding.local_variable_get(:until), "cursor" => cursor, "limit" => limit }
+      Record.new(@transport.json("GET", "/v1/usage/export", query: query))
+    end
+
     # Calls any API path with this client's key, retries, idempotency keys and
     # errors, and returns the parsed JSON answer. For an endpoint newer than this SDK.
     def request(method, path, query: nil, body: nil)

data/lib/withruntime/products.rb

@@ -81,7 +81,20 @@ module WithRuntime
     def backup(id, name: nil, labels: nil, retention_days: nil, wait: 60, idempotency_key: nil)
       Record.new(@t.json("POST", "/v1/volumes/#{seg(id)}:backup", body: Fields.body(name: name, labels: labels, retention_days: retention_days), wait: wait, key: idempotency_key))
     end
-    def set_backup_policy(id, daily: nil, retention_days: nil) = Record.new(@t.json("POST", "/v1/volumes/#{seg(id)}:backup-policy", body: Fields.body(daily: daily, retention_days: retention_days)))
+    # Automatic backups on or off and the days a daily one is kept; or a
+    # schedule of the volume's own: every_minutes (15 or more) or a five-field
+    # UTC cron, keeping the keep counts (last, hourly, daily, weekly, monthly,
+    # yearly). no_schedule: true goes back to daily backups.
+    def set_backup_policy(id, daily: nil, retention_days: nil, every_minutes: nil, cron: nil, keep: nil, no_schedule: false)
+      raise ArgumentError, "Give one of every_minutes, cron and no_schedule." if [every_minutes, cron, (no_schedule || nil)].compact.size > 1
+
+      body = Fields.body(daily: daily, retention_days: retention_days, keep: keep)
+      if every_minutes then body["schedule"] = { "everyMinutes" => every_minutes }
+      elsif cron then body["schedule"] = { "cron" => cron }
+      elsif no_schedule then body["schedule"] = nil
+      end
+      Record.new(@t.json("POST", "/v1/volumes/#{seg(id)}:backup-policy", body: body))
+    end
     def backups(volume_id: nil, state: nil, limit: nil) = page("/v1/volume-backups", { "volumeId" => volume_id, "state" => state, "limit" => limit })
     def get_backup(id) = Record.new(@t.json("GET", "/v1/volume-backups/#{seg(id)}"))
     def delete_backup(id) = Record.new(@t.json("POST", "/v1/volume-backups/#{seg(id)}:delete", body: {}))
@@ -146,8 +159,20 @@ module WithRuntime
       Record.new(@t.json("PUT", "/v1/egress-secrets/#{seg(name)}/rules", body: body))
     end
 
-    # Names, hosts and placeholders. Never values.
-    def list = @t.json("GET", "/v1/egress-secrets")["secrets"].map { |secret| Record.new(secret) }
+    # Names, hosts and placeholders. Never values. With +limit:+ (1 to 100)
+    # or +after:+, one page by name: the secrets named after +after+; the next
+    # page's +after+ is this one's last name. Without, every secret.
+    def list(limit: nil, after: nil)
+      secrets = []
+      start = after
+      loop do
+        page = @t.json("GET", "/v1/egress-secrets", query: { "limit" => limit, "after" => start })
+        secrets.concat(page["secrets"].map { |secret| Record.new(secret) })
+        return secrets if limit || after || !page["next"]
+
+        start = page["next"]
+      end
+    end
 
     # Erases a secret; its placeholder stops working.
     def delete(name)
@@ -377,7 +402,8 @@ module WithRuntime
 
     # Replaces the rules: +internet:+, +allow:+ (example.com, *.example.com, an
     # address or a CIDR range), +deny:+, and +connect:+ (host:port pairs beyond
-    # 80 and 443; paid accounts only).
+    # 80 and 443; paid accounts only). +internet: false+ with +allow:+ is
+    # allow-list only, stored as +internet: true+ with that list.
     def set(internet:, allow: nil, deny: nil, connect: nil)
       body = { "internet" => internet, "allow" => allow, "deny" => deny, "connect" => connect }.compact
       Record.new(@sandbox.transport.json("PUT", @sandbox.path("/network"), body: body))

data/lib/withruntime/sandbox.rb

@@ -214,8 +214,8 @@ module WithRuntime
     end
 
     # Starts copies of this sandbox as it is now (files, memory, running
-    # processes), each its own sandbox, on the same server, answered once they
-    # run. One copy without +count+; an array with it. If a copy fails, the
+    # processes), each its own sandbox, on its server while it has room and on
+    # another when it is full, answered once they run. One copy without +count+; an array with it. If a copy fails, the
     # error's +details["startedSandboxIds"]+ names the copies that did start.
     # +funding+ is accepted and ignored: copies run on free usage first, then credit.
     # +secrets: [name, ...]+ is the egress secrets the copies may use, by name:

data/lib/withruntime/transport.rb

@@ -378,8 +378,10 @@ module WithRuntime
 
     # Sends a call, retrying as the rules say, and returns the response once it
     # succeeded. With a block, the body is streamed to it.
+    # +bearer+ is sent instead of the API key: a webhook trigger's secret,
+    # which is all its calls carry.
     def send_call(http, method, path, query: nil, body: nil, raw: nil, accept: "application/json", wait: nil,
-                  key: nil, no_retry: false, room: nil, timeout: nil, cancel: nil, &stream)
+                  key: nil, no_retry: false, room: nil, timeout: nil, cancel: nil, bearer: nil, &stream)
       write = method != "GET"
       key = write ? (key || SecureRandom.uuid) : nil
       # room: nil for a call with no room wait; 0 for a create, wake, restart
@@ -400,7 +402,7 @@ module WithRuntime
         raise connection_error(true, write, key) if left <= 0
 
         request = Net::HTTPGenericRequest.new(method, !payload.nil?, true, target(path, query))
-        request["Authorization"] = "Bearer #{api_key}"
+        request["Authorization"] = "Bearer #{bearer || api_key}"
         request["Accept"] = accept
         request["X-Runtime-Client"] = @client
         request["User-Agent"] = "withruntime-ruby/#{VERSION}"

data/lib/withruntime/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WithRuntime
-  VERSION = "0.16.0"
+  VERSION = "0.17.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: withruntime
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Runtime
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-22 00:00:00.000000000 Z
+date: 2026-10-25 00:00:00.000000000 Z
 dependencies: []
 description: 'Linux sandboxes for agents, and every other Runtime Cloud product: streaming
   commands and terminals, files and watches, images, durable volumes and backups,