@vellumai/assistant 0.11.7-dev.202608281503.cbafd6c → 0.11.7-dev.202608282003.8ce5421

package/src/daemon/lifecycle.ts

@@ -461,19 +461,16 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
-    // Expire stale pending guardian requests left over from before this
-    // process started. Daemon-keyed by design: interaction-bound kinds die
-    // with THIS process's in-memory pendingInteractions map, so the daemon
-    // triggers the gateway op at its own boot — the gateway never runs it
-    // on its own restart. Two categories are cleaned up:
-    //
-    // 1. Interaction-bound kinds (tool_approval, pending_question) — their
-    //    in-memory pending-interaction session references are gone, so they
-    //    can never be completed.
-    // 2. Any pending request whose expiresAt has already passed — persistent
-    //    kinds (access_request, tool_grant_request) that expired while the
-    //    daemon was stopped are transitioned so dedup logic doesn't return
-    //    stale rows.
+    // Expire interaction-bound guardian requests (tool_approval,
+    // pending_question) left over from before this process started: their
+    // in-memory pending-interaction session references are gone, so they
+    // can never be completed. Daemon-keyed by design: the daemon triggers
+    // the gateway op at its own boot, and the gateway never runs it on its
+    // own restart. Persistent kinds (access_request, tool_grant_request) are
+    // never touched here, whatever their deadline: their expiry belongs to
+    // the periodic sweep, which owns the card-withdrawal and
+    // requester-notice fan-out, and the dedupe reads are deadline-aware so
+    // a past-deadline row waiting for the sweep suppresses nothing.
     //
     // Startup must not block on the gateway (daemon startup philosophy):
     // on failure the periodic sweep still reaps time-expired rows, and

package/src/oauth/scope-utils.ts

@@ -24,6 +24,54 @@ export function scopeDifference(
   );
 }
 
+/**
+ * Split a scope list the way the provider writes it.
+ *
+ * Providers (GitHub, Slack) may return comma-separated scopes regardless of
+ * the separator used to join outbound authorize URLs, so the default tolerates
+ * both spaces and commas. A provider that explicitly configures a non-default
+ * separator (Linear uses ",") is honored, keeping configured scopes
+ * round-tripping symmetrically.
+ *
+ * The one parser for both directions: token responses and authorize
+ * parameters. Two copies would let a provider-format fix land on one and not
+ * the other.
+ */
+export function parseScopeList(
+  raw: string,
+  scopeSeparator: string = " ",
+): string[] {
+  const splitPattern = scopeSeparator === " " ? /[ ,]/ : scopeSeparator;
+  return raw
+    .split(splitPattern)
+    .map((scope) => scope.trim())
+    .filter(Boolean);
+}
+
+/**
+ * The scopes the stored access token is expected to carry.
+ *
+ * A provider that asks for user scopes alongside bot scopes issues two grants
+ * from one authorization. `exchangeCodeForTokens` stores the `authed_user`
+ * token in that case and records that token's own grant as `grantedScopes`, so
+ * coverage has to be measured against the request that produced the stored
+ * token: `user_scope` where the provider sends one, the `scope` parameter
+ * otherwise. Measuring a user grant against the bot request reports scopes the
+ * authorization could never place on that token.
+ */
+export function expectedScopesForStoredToken(
+  defaultScopes: string[],
+  authorizeParams: Record<string, string> | undefined,
+  scopeSeparator?: string,
+): string[] {
+  const userScope = authorizeParams?.user_scope;
+  if (typeof userScope !== "string") {
+    return defaultScopes;
+  }
+  const parsed = parseScopeList(userScope, scopeSeparator);
+  return parsed.length > 0 ? parsed : defaultScopes;
+}
+
 const GMAIL_FULL_ACCESS_SCOPE = "https://mail.google.com/";
 const GMAIL_READONLY_SCOPE = "https://www.googleapis.com/auth/gmail.readonly";
 

package/src/persistence/db-connection.ts

@@ -1,8 +1,9 @@
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, join, resolve, sep } from "node:path";
+import { join, sep } from "node:path";
 import { Database } from "bun:sqlite";
 
+import { canonicalizePathThroughExistingParent } from "@vellumai/environments/test-path-guard";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { getLogsDbPath } from "../util/logs-db-path.js";
@@ -15,25 +16,6 @@ import { wrapSqliteForSlowQueryLogging } from "./slow-query-log.js";
 
 export type DrizzleDb = ReturnType<typeof drizzle<typeof schema>>;
 
-function canonicalizePathThroughExistingParent(path: string): string {
-  const resolvedPath = resolve(path);
-  const pendingSegments: string[] = [];
-  let currentPath = resolvedPath;
-
-  while (true) {
-    try {
-      return resolve(realpathSync(currentPath), ...pendingSegments.reverse());
-    } catch {
-      const parentPath = dirname(currentPath);
-      if (parentPath === currentPath) {
-        return resolvedPath;
-      }
-      pendingSegments.push(basename(currentPath));
-      currentPath = parentPath;
-    }
-  }
-}
-
 /**
  * Guard against opening a real workspace database during tests. Shared by
  * every connection opener (main, logs, memory) so a misconfigured test run

package/src/persistence/embeddings/__tests__/embedding-local-lifecycle.test.ts

@@ -18,8 +18,10 @@ import { getEmbedWorkerPidPath } from "../../../util/platform.js";
 import {
   classifyWorkerOwnership,
   listWorkerProcesses,
-  LocalEmbeddingBackend,
-} from "../embedding-local.js";
+} from "../../../util/worker-ownership.js";
+import { ORPHAN_STOP_TIMEOUT_MS } from "../../../util/worker-process.js";
+import { EMBEDDING_SHUTDOWN_BUDGET_MS } from "../embedding-backend.js";
+import { LocalEmbeddingBackend } from "../embedding-local.js";
 
 /** Reach past `private`, which is compile-time only, so tests drive real state. */
 type Internals = any;
@@ -753,3 +755,14 @@ describe("model matching", () => {
     ).toEqual([proc.pid]);
   });
 });
+
+// The daemon's orphan reclaim SIGTERMs a stale memory worker and waits
+// ORPHAN_STOP_TIMEOUT_MS before SIGKILL. That worker's shutdown reaps the ONNX
+// subprocess it owns, bounded at EMBEDDING_SHUTDOWN_BUDGET_MS + 1s. If the
+// reclaim ceiling does not outlast the reap, reclaiming kills the worker
+// mid-reap and strands the subprocess, which is the JARVIS-1125 failure.
+test("orphan reclaim outlasts the embedding reap it must not truncate", () => {
+  expect(ORPHAN_STOP_TIMEOUT_MS).toBeGreaterThan(
+    EMBEDDING_SHUTDOWN_BUDGET_MS + 1_000,
+  );
+});

package/src/persistence/embeddings/embedding-local.ts

@@ -13,13 +13,15 @@ import {
   getEmbeddingModelsDir,
   getEmbedWorkerPidPath,
 } from "../../util/platform.js";
-import {
-  listProcessTable,
-  readRawProcessCommand,
-} from "../../util/process-table.js";
+import { isProcessAlive } from "../../util/process-liveness.js";
 import { PromiseGuard } from "../../util/promise-guard.js";
 import { workerComputeEnv } from "../../util/worker-compute.js";
 import { workerMemoryEnv } from "../../util/worker-memory.js";
+import {
+  classifyWorkerOwnership,
+  listWorkerProcesses,
+  pid1OwnsWorkers,
+} from "../../util/worker-ownership.js";
 import { EmbeddingRuntimeManager } from "./embedding-runtime-manager.js";
 import {
   type EmbeddingBackend,
@@ -87,113 +89,6 @@ async function didSettle(
   return result !== timeout;
 }
 
-/** Whether a PID names a live process. */
-function isProcessAlive(pid: number): boolean {
-  try {
-    // Signal 0 probes for liveness without delivering a signal.
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-interface WorkerProcess {
-  pid: number;
-  ppid: number;
-}
-
-/**
- * What this process may do with an embed worker it found in the process table.
- *
- * - `reclaim`: parented to us, a worker we started and lost track of. Reaping
- *   it is what enforces one live worker per owning process.
- * - `orphan`: reparented to init, or its owner is gone. Nobody else will ever
- *   clean it up.
- * - `foreign`: owned by another live process. The memory-worker process runs
- *   its own backend against this same workspace and is entitled to its own
- *   worker; signalling it is what made the two replace each other in a loop.
- *
- * A parent of PID 1 is ambiguous, and resolving it wrongly in either direction
- * costs something real. `docker-entrypoint.sh` execs the daemon, so PID 1 can
- * BE the daemon and its child a healthy sibling's worker. Under `docker run
- * --init`, and on any host, PID 1 is an init process instead, so the same
- * parentage means the owner died and the worker needs reclaiming. Callers
- * therefore pass what PID 1 actually is rather than inferring it from whether
- * the deployment is containerized, which is true in both container shapes.
- */
-export type WorkerOwnership = "reclaim" | "orphan" | "foreign";
-
-export function classifyWorkerOwnership(
-  worker: WorkerProcess,
-  selfPid: number,
-  isOwnerAlive: (pid: number) => boolean,
-  pid1OwnsWorkers: boolean,
-): WorkerOwnership {
-  if (worker.ppid === selfPid) {
-    return "reclaim";
-  }
-  if (worker.ppid <= 1) {
-    return pid1OwnsWorkers ? "foreign" : "orphan";
-  }
-  if (!isOwnerAlive(worker.ppid)) {
-    return "orphan";
-  }
-  return "foreign";
-}
-
-/** Entrypoint the daemon is exec'd with, including inside a container. */
-const DAEMON_ENTRYPOINT_MARKER = "daemon/main";
-
-/**
- * Whether PID 1 is an assistant daemon rather than an init process.
- *
- * True only where the daemon was exec'd as PID 1 (`docker-entrypoint.sh`),
- * which is what makes a worker parented to 1 a live sibling's rather than an
- * orphan. Under `docker run --init` PID 1 is docker-init and under launchd or
- * systemd it is the system init, so both answer false and PID-1 orphans stay
- * reclaimable. Unreadable means false, which keeps the reclaiming behaviour.
- */
-function pid1OwnsEmbedWorkers(): boolean {
-  if (process.pid === 1) {
-    return true;
-  }
-  return readRawProcessCommand(1)?.includes(DAEMON_ENTRYPOINT_MARKER) ?? false;
-}
-
-/**
- * Live embed-worker processes for this workspace, as `(pid, ppid)` pairs.
- *
- * Ownership of an embed worker is recorded by the OS process tree, not by the
- * PID file: a worker's parent IS its owner. The process table is therefore the
- * authoritative answer to "whose worker is this", and unlike the PID file it
- * survives a crash and cannot be overwritten by a second owner. That matters
- * because the daemon and the memory-worker process legitimately run one worker
- * each against the same workspace.
- *
- * Matches on the absolute worker script path, which lives under THIS
- * workspace's embedding-models directory and is therefore unique per assistant
- * instance, so a sibling instance's workers never match. Raw command lines are
- * read for matching only, never stored or logged: process arguments can carry
- * secrets (see the redaction note in `util/process-tree.ts`).
- */
-export function listWorkerProcesses(
-  workerPath: string,
-  model?: string,
-): WorkerProcess[] {
-  try {
-    return listProcessTable()
-      .filter(
-        (row) =>
-          row.command.includes(workerPath) &&
-          (!model || row.command.split(/\s+/).includes(model)),
-      )
-      .map(({ pid, ppid }) => ({ pid, ppid }));
-  } catch {
-    return [];
-  }
-}
-
 /**
  * Local embedding backend using @huggingface/transformers (ONNX Runtime).
  * Runs BAAI/bge-small-en-v1.5 locally — no API calls, no network required.
@@ -874,7 +769,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
         worker,
         process.pid,
         isProcessAlive,
-        pid1OwnsEmbedWorkers(),
+        pid1OwnsWorkers(),
       );
       if (ownership === "foreign") {
         continue;

package/src/runtime/access-request-helper.ts

@@ -11,6 +11,8 @@
  * principal so access requests cannot bind to stale/cross-assistant contacts.
  */
 
+import { isGuardianRequestExpired } from "@vellumai/gateway-client";
+
 import {
   createGuardianRequest,
   listGuardianRequestsOrEmpty,
@@ -228,13 +230,19 @@ export async function notifyGuardianOfAccessRequest(
   // notified: true with the existing request ID so callers know the guardian
   // was already notified. A degraded (empty) read falls through to creation,
   // whose fail-closed throw prevents a prompt without a persisted request.
-  const existingPending = await listGuardianRequestsOrEmpty({
-    status: "pending",
-    requesterExternalUserId: actorExternalId,
-    sourceChannel,
-    kind: "access_request",
-    sourceConversationId: conversationId,
-  });
+  // Past-deadline rows never dedupe: a pending row can sit past its
+  // expiresAt until the sweep expires it, it is already undecidable, and
+  // letting it absorb a fresh attempt would silently drop the new guardian
+  // notification.
+  const existingPending = (
+    await listGuardianRequestsOrEmpty({
+      status: "pending",
+      requesterExternalUserId: actorExternalId,
+      sourceChannel,
+      kind: "access_request",
+      sourceConversationId: conversationId,
+    })
+  ).filter((r) => !isGuardianRequestExpired(r));
   if (existingPending.length > 0) {
     log.debug(
       { sourceChannel, actorExternalId, existingId: existingPending[0].id },

package/src/runtime/routes/integrations/slack/channel.ts

@@ -19,8 +19,39 @@ import {
 } from "../../../../daemon/handlers/config-slack-channel.js";
 import { ACTOR_PRINCIPALS } from "../../../auth/route-policy.js";
 import { BadRequestError } from "../../errors.js";
+import { parseBody } from "../../parse-body.js";
 import type { RouteDefinition, RouteHandlerArgs } from "../../types.js";
 
+// ---------------------------------------------------------------------------
+// Body schemas
+//
+// Each is named once and used twice: as the route's `requestBody`, a codegen
+// signal only, and by `parseBody` in the handler, which is what rejects a
+// malformed request. One declaration keeps the wire contract and the runtime
+// check in agreement.
+// ---------------------------------------------------------------------------
+
+/**
+ * Every field is optional because `setSlackChannelConfig` accepts any subset:
+ * a user token alone is a valid update that leaves the bot and app tokens in
+ * place. The wizard requires both bot and app tokens, and enforces that in
+ * `use-save-slack-config.ts` where that requirement belongs.
+ */
+const SetSlackChannelConfigBody = z.object({
+  botToken: z.string().optional().describe("Slack bot token"),
+  appToken: z.string().optional().describe("Slack app-level token"),
+  userToken: z
+    .string()
+    .optional()
+    .describe("Slack user token, for reading channels the bot is not in"),
+});
+
+const PatchSlackChannelConfigBody = z.object({
+  threadMode: SlackThreadMode.describe(
+    "Controls whether the bot follows threads after an initial @mention",
+  ).optional(),
+});
+
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -32,22 +63,19 @@ async function handleGetSlackChannelConfig() {
 export async function handleSetSlackChannelConfig({
   body = {},
 }: RouteHandlerArgs) {
-  const { botToken, appToken, userToken } = body as {
-    botToken?: string;
-    appToken?: string;
-    userToken?: string;
-  };
+  const { botToken, appToken, userToken } = parseBody(
+    SetSlackChannelConfigBody,
+    body,
+  );
   const result = await setSlackChannelConfig(botToken, appToken, userToken);
   if (!result.success) {
-    throw new BadRequestError(
-      (result as { error?: string }).error ?? "Failed to set Slack config",
-    );
+    throw new BadRequestError(result.error ?? "Failed to set Slack config");
   }
   return result;
 }
 
 async function handlePatchSlackChannelConfig({ body = {} }: RouteHandlerArgs) {
-  const { threadMode } = body as { threadMode?: string };
+  const { threadMode } = parseBody(PatchSlackChannelConfigBody, body);
   if (threadMode !== undefined) {
     const parsed = SlackThreadMode.safeParse(threadMode);
     if (!parsed.success) {
@@ -95,10 +123,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Validate and store Slack channel credentials.",
     tags: ["integrations"],
     handler: handleSetSlackChannelConfig,
-    requestBody: z.object({
-      botToken: z.string().describe("Slack bot token"),
-      appToken: z.string().describe("Slack app-level token"),
-    }),
+    requestBody: SetSlackChannelConfigBody,
     responseBody: SlackChannelConfigResultSchema,
   },
   {
@@ -113,11 +138,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Update Slack channel behavior settings (e.g. thread mode).",
     tags: ["integrations"],
     handler: handlePatchSlackChannelConfig,
-    requestBody: z.object({
-      threadMode: SlackThreadMode.describe(
-        "Controls whether the bot follows threads after an initial @mention",
-      ).optional(),
-    }),
+    requestBody: PatchSlackChannelConfigBody,
     responseBody: SlackChannelConfigResultSchema,
   },
   {

package/src/runtime/tool-grant-request-helper.ts

@@ -11,6 +11,8 @@
  * - Notification routing goes through emitNotificationSignal().
  */
 
+import { isGuardianRequestExpired } from "@vellumai/gateway-client";
+
 import {
   createGuardianRequest,
   listGuardianRequestsOrEmpty,
@@ -124,8 +126,10 @@ export async function createOrReuseToolGrantRequest(
     kind: "tool_grant_request",
     toolName,
   });
+  // Past-deadline rows never dedupe: see the access-request helper's note.
   const dedupeMatch = existing.find(
     (r) =>
+      !isGuardianRequestExpired(r) &&
       r.inputDigest === inputDigest &&
       r.guardianExternalUserId === binding.guardianExternalUserId,
   );

package/src/security/oauth2.ts

@@ -20,6 +20,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { createServer, type Server } from "node:http";
 
 import { getIsPlatform } from "../config/env-registry.js";
+import { parseScopeList } from "../oauth/scope-utils.js";
 import { getLogger } from "../util/logger.js";
 import { renderOAuthCompletionPage as renderLoopbackPage } from "./oauth-completion-page.js";
 
@@ -249,19 +250,9 @@ export async function exchangeCodeForTokens(
       (tokenData.token_type as string | undefined),
   };
 
-  // Defensive split: providers (e.g. GitHub, Slack) may return comma-separated
-  // scopes in token responses regardless of the scope_separator used to join
-  // outbound authorize URLs, so we tolerate both spaces and commas here. When
-  // a provider explicitly configures a non-default separator (e.g. Linear uses
-  // ","), we honor that to keep symmetric round-tripping of configured scopes.
-  const splitPattern =
-    config.scopeSeparator === " " ? /[ ,]/ : config.scopeSeparator;
   const grantedScopes =
     typeof tokens.scope === "string"
-      ? tokens.scope
-          .split(splitPattern)
-          .map((s) => s.trim())
-          .filter(Boolean)
+      ? parseScopeList(tokens.scope, config.scopeSeparator)
       : [...config.scopes];
 
   return { tokens, grantedScopes, rawTokenResponse: tokenData };

package/src/tools/browser/__tests__/browser-status.test.ts

@@ -5,7 +5,7 @@ import type { ToolContext } from "../../types.js";
 import {
   BROWSER_STATUS_INPUT_FIELD,
   BROWSER_STATUS_MODE,
-  CHROME_WEB_STORE_INSTALL_URL,
+  CHROME_EXTENSION_INSTALL_HINT,
 } from "../browser-status-constants.js";
 import { CdpError } from "../cdp-client/errors.js";
 
@@ -215,9 +215,10 @@ describe("executeBrowserStatus", () => {
     expect(extension.summary).toContain("no Chrome Extension is connected");
     expect(extension.verified).toBe("preflight");
     expect(extension.details.transport).toBe("extension-ws");
-    expect(extension.userActions.join("\n")).toContain(
-      CHROME_WEB_STORE_INSTALL_URL,
-    );
+    expect(extension.userActions).toEqual([
+      CHROME_EXTENSION_INSTALL_HINT,
+      "Tell the user to make sure a browser is open with the Vellum Chrome extension on.",
+    ]);
   });
 
   test("probe failure diagnostics include remediation actions", async () => {
@@ -241,9 +242,10 @@ describe("executeBrowserStatus", () => {
     expect(extension).toBeDefined();
     expect(extension.available).toBe(false);
     expect(extension.summary).toContain("probe failed");
-    expect(extension.userActions.join("\n")).toContain(
-      CHROME_WEB_STORE_INSTALL_URL,
-    );
+    expect(extension.userActions).toEqual([
+      CHROME_EXTENSION_INSTALL_HINT,
+      "Tell the user to make sure a browser is open with the Vellum Chrome extension on.",
+    ]);
   });
 
   test("recommendation order follows auto candidate precedence with available extension", async () => {

package/src/tools/browser/browser-execution.ts

@@ -41,7 +41,6 @@ import {
   CDP_INSPECT_STATUS_DISCOVERY_CODE,
   CHROME_EXTENSION_INSTALL_HINT,
   CHROME_WEB_STORE_INSTALL_URL,
-  EXTENSION_STATUS_ERROR_MARKER,
 } from "./browser-status-constants.js";
 import {
   formatAxSnapshot,
@@ -2488,10 +2487,10 @@ function modeTradeoffs(mode: StatusCheckMode): string[] {
   return MODE_TRADEOFFS[mode];
 }
 
-function extensionSetupActions(): string[] {
+function extensionConnectionActions(): string[] {
   return [
     CHROME_EXTENSION_INSTALL_HINT,
-    "Open the extension and pair with your assistant.",
+    "Tell the user to make sure a browser is open with the Vellum Chrome extension on.",
   ];
 }
 
@@ -2520,49 +2519,14 @@ function extractDiscoveryCodes(error: CdpError): string[] {
   return dedupeStrings(codes);
 }
 
-function containsTokenCaseInsensitive(text: string, token: string): boolean {
-  return text.toLowerCase().includes(token.toLowerCase());
-}
-
 function probeFailureActions(mode: StatusCheckMode, error: CdpError): string[] {
   const actions: string[] = [];
-  const message = error.message.toLowerCase();
   const discoveryCodes = extractDiscoveryCodes(error).map((c) =>
     c.toLowerCase(),
   );
 
   if (mode === BROWSER_STATUS_MODE.EXTENSION) {
-    actions.push(...extensionSetupActions());
-    if (
-      containsTokenCaseInsensitive(
-        message,
-        EXTENSION_STATUS_ERROR_MARKER.UNAUTHORIZED_ORIGIN,
-      )
-    ) {
-      actions.push(
-        "Ensure this extension ID is present in chrome-extension-allowlist.local.json in $GATEWAY_SECURITY_DIR and restart the assistant.",
-      );
-    }
-    if (
-      containsTokenCaseInsensitive(
-        message,
-        EXTENSION_STATUS_ERROR_MARKER.NATIVE_MESSAGING_HOST,
-      )
-    ) {
-      actions.push(
-        "Reinstall the native messaging host manifest and confirm it allows this extension ID.",
-      );
-    }
-    if (
-      containsTokenCaseInsensitive(
-        message,
-        EXTENSION_STATUS_ERROR_MARKER.HTTP_401,
-      )
-    ) {
-      actions.push(
-        "Re-pair the extension so it refreshes its local relay credential.",
-      );
-    }
+    actions.push(...extensionConnectionActions());
   }
 
   if (mode === BROWSER_STATUS_MODE.CDP_INSPECT) {
@@ -2654,7 +2618,7 @@ async function checkExtensionModeStatus(
       autoCandidate,
       summary:
         "Extension mode is unavailable: no Chrome Extension is connected.",
-      userActions: extensionSetupActions(),
+      userActions: extensionConnectionActions(),
       tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
       details: { transport: "extension-ws" },
     };

package/src/tools/browser/browser-status-constants.ts

@@ -20,12 +20,6 @@ export const BROWSER_STATUS_INPUT_FIELD = {
   CHECK_LOCAL_LAUNCH: "check_local_launch",
 } as const;
 
-export const EXTENSION_STATUS_ERROR_MARKER = {
-  UNAUTHORIZED_ORIGIN: "unauthorized_origin",
-  NATIVE_MESSAGING_HOST: "native messaging host",
-  HTTP_401: "401",
-} as const;
-
 /** Chrome Web Store listing for the Vellum Assistant browser extension. */
 export const CHROME_WEB_STORE_INSTALL_URL =
   "https://chromewebstore.google.com/detail/vellum-assistant-browser/hphbdmpffeigpcdjkckleobjmhhokpne";