@vellumai/cli 0.7.0 → 0.7.2

package/src/commands/ps.ts

@@ -28,6 +28,10 @@ import { pgrepExact } from "../lib/pgrep";
 import { probePort } from "../lib/port-probe";
 import { withStatusEmoji } from "../lib/status-emoji";
 import { execOutput } from "../lib/step-runner";
+import {
+  syncCloudAssistants,
+  type SyncLogger,
+} from "../lib/sync-cloud-assistants";
 
 // ── Table formatting helpers ────────────────────────────────────
 
@@ -468,7 +472,7 @@ async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
 
 // ── List all assistants (no arg) ────────────────────────────────
 
-async function listAllAssistants(): Promise<void> {
+async function listAllAssistants(verbose: boolean): Promise<void> {
   const { name: envName, source: envSource } = resolveEnvironmentSource();
   const sourceLabels: Record<typeof envSource, string> = {
     flag: "--environment flag",
@@ -476,7 +480,31 @@ async function listAllAssistants(): Promise<void> {
     config: "~/.config/vellum/environment",
     default: "default",
   };
-  console.log(`Environment: ${envName} (${sourceLabels[envSource]})\n`);
+  console.log(`Environment: ${envName} (${sourceLabels[envSource]})`);
+
+  const log: SyncLogger | undefined = verbose
+    ? (msg) => console.log(`  [verbose] ${msg}`)
+    : undefined;
+
+  // Refresh cloud assistants from the platform before listing.
+  const syncResult = await syncCloudAssistants({ log });
+
+  // Show platform login status
+  if (syncResult) {
+    const parts = [`Platform: logged in`];
+    if (syncResult.email) parts[0] += ` as ${syncResult.email}`;
+    if (syncResult.added > 0 || syncResult.removed > 0) {
+      const changes: string[] = [];
+      if (syncResult.added > 0) changes.push(`${syncResult.added} added`);
+      if (syncResult.removed > 0)
+        changes.push(`${syncResult.removed} removed`);
+      parts.push(`(${changes.join(", ")})`);
+    }
+    console.log(parts.join(" "));
+  } else {
+    console.log("Platform: not logged in");
+  }
+  console.log("");
 
   const assistants = loadAllAssistants();
   const activeId = getActiveAssistant();
@@ -599,21 +627,28 @@ async function listAllAssistants(): Promise<void> {
 export async function ps(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: vellum ps [<name>]");
+    console.log("Usage: vellum ps [<name>] [--verbose]");
     console.log("");
     console.log(
       "List all assistants, or show processes for a specific assistant.",
     );
     console.log("");
     console.log("Arguments:");
-    console.log("  <name>    Show processes for the named assistant");
+    console.log("  <name>       Show processes for the named assistant");
+    console.log("");
+    console.log("Options:");
+    console.log(
+      "  --verbose    Show diagnostic logs (platform sync, auth issues)",
+    );
     process.exit(0);
   }
 
-  const assistantId = process.argv[3];
+  const verbose = args.includes("--verbose");
+  const positional = args.filter((a) => !a.startsWith("--"));
+  const assistantId = positional[0];
 
   if (!assistantId) {
-    await listAllAssistants();
+    await listAllAssistants(verbose);
     return;
   }
 

package/src/commands/restore.ts

@@ -9,13 +9,11 @@ import {
 import {
   readPlatformToken,
   rollbackPlatformAssistant,
-  platformImportPreflight,
-  platformImportBundle,
-  platformRequestUploadUrl,
+  platformRequestSignedUrl,
   platformUploadToSignedUrl,
   platformImportPreflightFromGcs,
   platformImportBundleFromGcs,
-  platformPollImportStatus,
+  platformPollJobStatus,
 } from "../lib/platform-client.js";
 import { performDockerRollback } from "../lib/upgrade-lifecycle.js";
 
@@ -181,24 +179,20 @@ async function restorePlatform(
     process.exit(1);
   }
 
-  // Step 1.5 — Upload to GCS via signed URL (with fallback to inline)
-  let bundleKey: string | null = null;
-  try {
-    const { uploadUrl, bundleKey: key } = await platformRequestUploadUrl(
-      token,
-      entry.runtimeUrl,
-    );
-    bundleKey = key;
-    console.log("Uploading bundle...");
-    await platformUploadToSignedUrl(uploadUrl, new Uint8Array(bundleData));
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("not available")) {
-      bundleKey = null;
-    } else {
-      throw err;
-    }
-  }
+  // Step 1.5 — Upload to GCS via signed URL.
+  // We deliberately omit min/max runtime version here: restore uploads an
+  // arbitrary .vbundle from disk (often produced by a different runtime
+  // than the one we'd query right now), and the bundle's own manifest is
+  // the authority on its compatibility band. The platform skips the
+  // version gate when these fields are absent and re-derives compat from
+  // the manifest when it processes the import.
+  const { url: uploadUrl, bundleKey } = await platformRequestSignedUrl(
+    { operation: "upload" },
+    token,
+    entry.runtimeUrl,
+  );
+  console.log("Uploading bundle...");
+  await platformUploadToSignedUrl(uploadUrl, new Uint8Array(bundleData));
 
   // Step 2 — Dry-run path
   if (opts.dryRun) {
@@ -213,17 +207,11 @@ async function restorePlatform(
 
     let preflightResult: { statusCode: number; body: Record<string, unknown> };
     try {
-      preflightResult = bundleKey
-        ? await platformImportPreflightFromGcs(
-            bundleKey,
-            token,
-            entry.runtimeUrl,
-          )
-        : await platformImportPreflight(
-            new Uint8Array(bundleData),
-            token,
-            entry.runtimeUrl,
-          );
+      preflightResult = await platformImportPreflightFromGcs(
+        bundleKey,
+        token,
+        entry.runtimeUrl,
+      );
     } catch (err) {
       if (err instanceof Error && err.name === "TimeoutError") {
         console.error("Error: Preflight request timed out after 2 minutes.");
@@ -353,13 +341,11 @@ async function restorePlatform(
 
   let importResult: { statusCode: number; body: Record<string, unknown> };
   try {
-    importResult = bundleKey
-      ? await platformImportBundleFromGcs(bundleKey, token, entry.runtimeUrl)
-      : await platformImportBundle(
-          new Uint8Array(bundleData),
-          token,
-          entry.runtimeUrl,
-        );
+    importResult = await platformImportBundleFromGcs(
+      bundleKey,
+      token,
+      entry.runtimeUrl,
+    );
   } catch (err) {
     if (err instanceof Error && err.name === "TimeoutError") {
       console.error("Error: Import request timed out after 5 minutes.");
@@ -420,13 +406,9 @@ async function restorePlatform(
     while (Date.now() < deadline) {
       await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
 
-      let status: {
-        status: string;
-        result?: Record<string, unknown>;
-        error?: string;
-      };
+      let status: Awaited<ReturnType<typeof platformPollJobStatus>>;
       try {
-        status = await platformPollImportStatus(jobId, token, entry.runtimeUrl);
+        status = await platformPollJobStatus(jobId, token, entry.runtimeUrl);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         if (msg.includes("not found")) {
@@ -451,7 +433,10 @@ async function restorePlatform(
       }
 
       if (status.status === "complete") {
-        importResult = { statusCode: 200, body: status.result ?? {} };
+        importResult = {
+          statusCode: 200,
+          body: (status.result as Record<string, unknown>) ?? {},
+        };
         break;
       }
 

package/src/commands/setup.ts

@@ -1,43 +1,6 @@
 import { createInterface } from "readline";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
 
-function getVellumDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
-
-function getEnvFilePath(): string {
-  return join(getVellumDir(), ".env");
-}
-
-function readEnvFile(): Record<string, string> {
-  const envPath = getEnvFilePath();
-  const vars: Record<string, string> = {};
-  if (!existsSync(envPath)) return vars;
-
-  const content = readFileSync(envPath, "utf-8");
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIdx = trimmed.indexOf("=");
-    if (eqIdx === -1) continue;
-    const key = trimmed.slice(0, eqIdx).trim();
-    const value = trimmed.slice(eqIdx + 1).trim();
-    vars[key] = value;
-  }
-  return vars;
-}
-
-function writeEnvFile(vars: Record<string, string>): void {
-  const envPath = getEnvFilePath();
-  const dir = dirname(envPath);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-
-  const lines = Object.entries(vars).map(([k, v]) => `${k}=${v}`);
-  writeFileSync(envPath, lines.join("\n") + "\n", { mode: 0o600 });
-}
+import { resolveAssistant } from "../lib/assistant-config.js";
 
 async function promptMasked(prompt: string): Promise<string> {
   return new Promise((resolve) => {
@@ -46,7 +9,6 @@ async function promptMasked(prompt: string): Promise<string> {
       output: process.stdout,
     });
 
-    // Disable echoing by writing the prompt manually and intercepting keystrokes
     process.stdout.write(prompt);
 
     const stdin = process.stdin;
@@ -60,7 +22,6 @@ async function promptMasked(prompt: string): Promise<string> {
       const char = key.toString("utf-8");
 
       if (char === "\r" || char === "\n") {
-        // Enter pressed
         stdin.removeListener("data", onData);
         if (stdin.isTTY) {
           stdin.setRawMode(wasRaw ?? false);
@@ -69,11 +30,9 @@ async function promptMasked(prompt: string): Promise<string> {
         rl.close();
         resolve(input);
       } else if (char === "\u0003") {
-        // Ctrl+C
         process.stdout.write("\n");
         process.exit(1);
       } else if (char === "\u007F" || char === "\b") {
-        // Backspace
         if (input.length > 0) {
           input = input.slice(0, -1);
           process.stdout.write("\b \b");
@@ -111,39 +70,23 @@ export async function setup(): Promise<void> {
     console.log("");
     console.log("Interactive wizard to configure API keys.");
     console.log(
-      "Keys are validated against their APIs and saved to <BASE_DATA_DIR>/.vellum/.env.",
+      "Injects secrets into your running assistant via the gateway API.",
     );
     process.exit(0);
   }
 
-  console.log("Vellum Setup");
-  console.log("============\n");
-
-  const existingVars = readEnvFile();
-  const hasExistingKey = !!existingVars.ANTHROPIC_API_KEY;
+  const entry = resolveAssistant();
+  if (!entry) {
+    console.error(
+      "Error: No active assistant found. Run `vellum hatch` first.",
+    );
+    process.exit(1);
+  }
 
-  if (hasExistingKey) {
-    const masked =
-      existingVars.ANTHROPIC_API_KEY.slice(0, 7) +
-      "..." +
-      existingVars.ANTHROPIC_API_KEY.slice(-4);
-    console.log(`Anthropic API key is already configured (${masked}).`);
+  const gatewayUrl = entry.localUrl ?? entry.runtimeUrl;
 
-    const rl = createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-    const answer = await new Promise<string>((resolve) => {
-      rl.question("Overwrite? [y/N] ", resolve);
-    });
-    rl.close();
-
-    if (answer.trim().toLowerCase() !== "y") {
-      console.log("\nSetup complete. No changes made.");
-      return;
-    }
-    console.log("");
-  }
+  console.log("Vellum Setup");
+  console.log("============\n");
 
   const apiKey = await promptMasked(
     "Enter your Anthropic API key (sk-ant-...): ",
@@ -164,9 +107,31 @@ export async function setup(): Promise<void> {
     process.exit(1);
   }
 
-  existingVars.ANTHROPIC_API_KEY = apiKey.trim();
-  writeEnvFile(existingVars);
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  };
+  if (entry.bearerToken) {
+    headers["Authorization"] = `Bearer ${entry.bearerToken}`;
+  }
+
+  const response = await fetch(`${gatewayUrl}/v1/secrets`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      type: "credential",
+      name: "ANTHROPIC_API_KEY",
+      value: apiKey.trim(),
+    }),
+    signal: AbortSignal.timeout(10_000),
+  });
+
+  if (!response.ok) {
+    console.error(
+      `Error: Failed to store API key in assistant (${response.status}).`,
+    );
+    process.exit(1);
+  }
 
-  console.log(`\nAPI key saved to ${getEnvFilePath()}`);
-  console.log("Setup complete.");
+  console.log("\nAPI key saved to assistant. Setup complete.");
 }

package/src/commands/ssh.ts

@@ -1,9 +1,6 @@
 import { spawn } from "child_process";
 
-import {
-  findAssistantByName,
-  loadLatestAssistant,
-} from "../lib/assistant-config";
+import { resolveAssistant } from "../lib/assistant-config";
 import type { AssistantEntry } from "../lib/assistant-config";
 import { dockerResourceNames } from "../lib/docker";
 import { getPlatformUrl, readPlatformToken } from "../lib/platform-client";
@@ -58,7 +55,7 @@ export async function ssh(): Promise<void> {
   }
 
   const name = process.argv[3];
-  const entry = name ? findAssistantByName(name) : loadLatestAssistant();
+  const entry = resolveAssistant(name);
 
   if (!entry) {
     if (name) {

package/src/commands/teleport.ts

@@ -17,11 +17,11 @@ import {
   getPlatformUrl,
   hatchAssistant,
   checkExistingPlatformAssistant,
-  platformInitiateExport,
   platformPollJobStatus,
   platformImportBundleFromGcs,
   platformImportPreflightFromGcs,
   platformRequestSignedUrl,
+  VersionMismatchError,
   ensureSelfHostedLocalRegistration,
   readGatewayCredential,
   reprovisionAssistantApiKey,
@@ -31,6 +31,7 @@ import {
 } from "../lib/platform-client.js";
 import {
   localRuntimeExportToGcs,
+  localRuntimeIdentity,
   localRuntimeImportFromGcs,
   localRuntimePollJobStatus,
   MigrationInProgressError,
@@ -255,13 +256,17 @@ async function getAccessToken(
 
 /**
  * Detect a 401 Unauthorized raised by `localRuntimeExportToGcs` /
- * `localRuntimeImportFromGcs`. Both throw Error with a message of the form
- * `"Local runtime <op> failed (401): ..."` when the gateway rejects the
- * cached guardian token.
+ * `localRuntimeImportFromGcs` / `localRuntimeIdentity`. They throw Error
+ * with a message of the form `"Local runtime <op> failed (401): ..."` or
+ * `"Failed to fetch runtime identity: 401 ..."` when the gateway rejects
+ * the cached guardian token.
  */
 function isRuntime401(err: unknown): boolean {
   const msg = err instanceof Error ? err.message : String(err);
-  return /Local runtime [^(]*failed \(401\)/.test(msg);
+  return (
+    /Local runtime [^(]*failed \(401\)/.test(msg) ||
+    /Failed to fetch runtime identity: 401\b/.test(msg)
+  );
 }
 
 /**
@@ -368,13 +373,40 @@ async function exportFromAssistant(
   }
 
   if (cloud === "local" || cloud === "docker") {
+    // Ask the source runtime which version it's running before requesting
+    // the signed upload URL. The bundle is produced by the daemon (not the
+    // CLI), so the daemon's version is what defines the bundle's
+    // `min_runtime_version`. Stamping with `cliPkg.version` instead would
+    // record an inaccurate compatibility band whenever the CLI/daemon have
+    // drifted (a normal case in real usage — `vellum upgrade` swaps the
+    // daemon, the CLI is updated separately).
+    let sourceRuntimeVersion: string;
+    try {
+      const identity = await callRuntimeWithAuthRetry(
+        entry.runtimeUrl,
+        entry.assistantId,
+        async (token) => localRuntimeIdentity(entry, token),
+      );
+      sourceRuntimeVersion = identity.version;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `Error: Could not fetch runtime identity from '${entry.assistantId}': ${msg}`,
+      );
+      process.exit(1);
+    }
+
     // Request a signed upload URL from the platform instance that will
     // eventually own the bundle (i.e. the one the importer will read from).
     // Passing the target's runtime URL here keeps upload and download on
     // the same platform — otherwise a non-default/stale platform URL would
     // cause the import to look at an empty object.
     const { url: uploadUrl, bundleKey } = await platformRequestSignedUrl(
-      { operation: "upload" },
+      {
+        operation: "upload",
+        minRuntimeVersion: sourceRuntimeVersion,
+        maxRuntimeVersion: null,
+      },
       platformToken,
       bundlePlatformUrl,
     );
@@ -391,7 +423,7 @@ async function exportFromAssistant(
         entry.runtimeUrl,
         entry.assistantId,
         async (token) => {
-          const r = await localRuntimeExportToGcs(entry.runtimeUrl, token, {
+          const r = await localRuntimeExportToGcs(entry, token, {
             uploadUrl,
             description: "teleport export",
           });
@@ -418,8 +450,7 @@ async function exportFromAssistant(
 
     const terminal = await pollJobUntilDone({
       label: "local-runtime export",
-      poll: () =>
-        localRuntimePollJobStatus(entry.runtimeUrl, accessToken, jobId),
+      poll: () => localRuntimePollJobStatus(entry, accessToken, jobId),
       // Large exports can take longer than a guardian-token lease. If the
       // runtime returns 401 mid-poll, re-lease a fresh token and rebind the
       // closure variable so the next poll uses it.
@@ -442,22 +473,68 @@ async function exportFromAssistant(
   }
 
   if (cloud === "vellum") {
-    // Platform source — initiate a server-side export. The platform writes
-    // the bundle to its own `exports/<org>/<id>.vbundle` key; we discover
-    // that key via the unified job-status endpoint's `bundle_key` field.
-    const { jobId } = await platformInitiateExport(
+    // Ask the managed runtime which version it's running so the signed-URL
+    // request records the bundle's actual `min_runtime_version`. The
+    // platform-managed runtime is the exporter; the CLI version is
+    // unrelated. Routed via the wildcard proxy with platform-token auth
+    // (resolveRuntimeUrl + migrationRequestHeaders inside
+    // localRuntimeIdentity).
+    let sourceRuntimeVersion: string;
+    try {
+      const identity = await localRuntimeIdentity(entry, platformToken);
+      sourceRuntimeVersion = identity.version;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `Error: Could not fetch runtime identity from '${entry.assistantId}': ${msg}`,
+      );
+      process.exit(1);
+    }
+
+    // Platform source — request a signed upload URL on the same platform
+    // instance the bundle will eventually be imported from, then ask the
+    // managed runtime to export directly to GCS. The runtime endpoint is
+    // reached via the platform's wildcard runtime proxy at
+    // `/v1/assistants/<id>/migrations/export-to-gcs` — the
+    // `localRuntimeExportToGcs` helper uses `resolveRuntimeMigrationUrl` to
+    // pick that shape for `cloud === "vellum"` and `migrationRequestHeaders`
+    // to send platform-token auth (no guardian-token bootstrap).
+    const { url: uploadUrl, bundleKey } = await platformRequestSignedUrl(
+      {
+        operation: "upload",
+        minRuntimeVersion: sourceRuntimeVersion,
+        maxRuntimeVersion: null,
+      },
       platformToken,
-      "teleport export",
-      entry.runtimeUrl,
+      bundlePlatformUrl,
     );
 
+    let jobId: string;
+    let exportPlatformToken = platformToken;
+    try {
+      ({ jobId } = await localRuntimeExportToGcs(entry, exportPlatformToken, {
+        uploadUrl,
+        description: "teleport export",
+      }));
+    } catch (err) {
+      if (err instanceof MigrationInProgressError) {
+        console.error(
+          `Error: Another teleport export is already in progress on '${entry.assistantId}' (job ${err.existingJobId}). Wait for it to finish or check its status, then re-run.`,
+        );
+        process.exit(1);
+      }
+      throw err;
+    }
+
     console.log(`Export started (job ${jobId})...`);
 
-    let exportPlatformToken = platformToken;
+    // Polling also goes through the wildcard proxy — `localRuntimePollJobStatus`
+    // builds `/v1/assistants/<id>/migrations/jobs/<jobId>` for `cloud === "vellum"`
+    // (the dedicated `/v1/migrations/jobs/{id}/` endpoint queries platform-side
+    // ImportJob records and 404s on runtime-created job IDs).
     const terminal = await pollJobUntilDone({
       label: "platform export",
-      poll: () =>
-        platformPollJobStatus(jobId, exportPlatformToken, entry.runtimeUrl),
+      poll: () => localRuntimePollJobStatus(entry, exportPlatformToken, jobId),
       // The platform token is normally static per-process, but re-reading the
       // on-disk credential covers the case where the user ran `vellum login`
       // in another terminal during a long migration. A persistent 401 after
@@ -478,14 +555,7 @@ async function exportFromAssistant(
       process.exit(1);
     }
 
-    if (!terminal.bundleKey) {
-      console.error(
-        "Export completed but the platform did not return a bundle_key. Is the platform up to date?",
-      );
-      process.exit(1);
-    }
-
-    return { bundleKey: terminal.bundleKey };
+    return { bundleKey };
   }
 
   console.error(
@@ -644,11 +714,56 @@ async function importToAssistant(
     // never touches the bytes. The URL must target the same platform the
     // bundle was uploaded to; otherwise the object won't exist on this
     // platform's GCS bucket.
-    const { url: bundleUrl } = await platformRequestSignedUrl(
-      { operation: "download", bundleKey },
-      platformToken,
-      bundlePlatformUrl,
-    );
+    //
+    // The platform's vbundle version gate compares the **target runtime's**
+    // version against the bundle's compatibility range. The CLI and the
+    // target assistant's daemon can diverge (assistants upgrade
+    // independently), so we MUST query the target runtime's `/v1/identity`
+    // for its version rather than sending `cliPkg.version`. Sending the CLI
+    // version here would falsely 422 a valid import (or pass a bundle the
+    // target can't actually load) whenever the two drift apart.
+    let targetRuntimeVersion: string;
+    try {
+      const identity = await callRuntimeWithAuthRetry(
+        entry.runtimeUrl,
+        entry.assistantId,
+        (token) => localRuntimeIdentity(entry, token),
+      );
+      targetRuntimeVersion = identity.version;
+    } catch (err) {
+      // Surface and abort — silently falling back to `cliPkg.version` would
+      // re-introduce the bug this code is fixing. If the runtime is
+      // unreachable, the import would fail downstream anyway.
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `Error: Could not read target runtime version from '${entry.assistantId}': ${msg}`,
+      );
+      console.error(`Try: vellum wake ${entry.assistantId}`);
+      process.exit(1);
+    }
+
+    let bundleUrl: string;
+    try {
+      const result = await platformRequestSignedUrl(
+        {
+          operation: "download",
+          bundleKey,
+          targetRuntimeVersion,
+        },
+        platformToken,
+        bundlePlatformUrl,
+      );
+      bundleUrl = result.url;
+    } catch (err) {
+      if (err instanceof VersionMismatchError) {
+        // 422 version_mismatch is terminal — the bundle's runtime range and
+        // the target runtime's version don't overlap. Surface the
+        // platform-formatted message and exit; do NOT retry.
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      throw err;
+    }
 
     console.log("Importing data...");
 
@@ -659,7 +774,7 @@ async function importToAssistant(
         entry.runtimeUrl,
         entry.assistantId,
         async (token) => {
-          const r = await localRuntimeImportFromGcs(entry.runtimeUrl, token, {
+          const r = await localRuntimeImportFromGcs(entry, token, {
             bundleUrl,
           });
           return { jobId: r.jobId, token };
@@ -682,8 +797,7 @@ async function importToAssistant(
 
     const terminal = await pollJobUntilDone({
       label: "local-runtime import",
-      poll: () =>
-        localRuntimePollJobStatus(entry.runtimeUrl, accessToken, jobId),
+      poll: () => localRuntimePollJobStatus(entry, accessToken, jobId),
       refreshOn401: async () => {
         accessToken = await getAccessToken(
           entry.runtimeUrl,