@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/tools/browser/cdp-client/factory.ts

@@ -67,7 +67,9 @@ export function recordDesktopAutoCooldown(): void {
  * window has not yet elapsed.
  */
 export function isDesktopAutoCooldownActive(cooldownMs: number): boolean {
-  if (_desktopAutoCooldownSince === 0 || cooldownMs <= 0) return false;
+  if (_desktopAutoCooldownSince === 0 || cooldownMs <= 0) {
+    return false;
+  }
   return Date.now() - _desktopAutoCooldownSince < cooldownMs;
 }
 
@@ -140,11 +142,15 @@ export function isHostBridgeCooldownActive(
   cooldownMs: number,
   sourceActorPrincipalId?: string,
 ): boolean {
-  if (cooldownMs <= 0) return false;
+  if (cooldownMs <= 0) {
+    return false;
+  }
   const since = _hostBridgeCooldownSince.get(
     hostBridgeCooldownKey(sourceActorPrincipalId),
   );
-  if (since === undefined) return false;
+  if (since === undefined) {
+    return false;
+  }
   return Date.now() - since < cooldownMs;
 }
 
@@ -280,25 +286,25 @@ export function buildPinnedCandidateList(
 
   switch (mode) {
     case "extension": {
-        const hostBrowserProxy = HostBrowserProxy.instance;
-        if (!hostBrowserProxy.hasExtensionClient(sourceActorPrincipalId)) {
-          throw new CdpError(
-            "transport_error",
-            `Pinned mode "extension" unavailable: no Chrome Extension connected`,
-            {
-              attemptDiagnostics: [
-                {
-                  candidateKind: "extension",
-                  inclusionReason: `pinned mode: extension`,
-                  stage: "candidate_selection",
-                  errorCode: "transport_error",
-                  errorMessage: "no Chrome Extension connected",
-                },
-              ],
-            },
-          );
-        }
-        return [
+      const hostBrowserProxy = HostBrowserProxy.instance;
+      if (!hostBrowserProxy.hasExtensionClient(sourceActorPrincipalId)) {
+        throw new CdpError(
+          "transport_error",
+          `Pinned mode "extension" unavailable: no Chrome Extension connected`,
+          {
+            attemptDiagnostics: [
+              {
+                candidateKind: "extension",
+                inclusionReason: `pinned mode: extension`,
+                stage: "candidate_selection",
+                errorCode: "transport_error",
+                errorMessage: "no Chrome Extension connected",
+              },
+            ],
+          },
+        );
+      }
+      return [
         {
           kind: "extension",
           reason: "pinned mode: extension",
@@ -429,7 +435,10 @@ export function buildPinnedCandidateList(
  *
  * Exported for testing.
  */
-export function buildCandidateList(context: ToolContext, targetClientId?: string): BackendCandidate[] {
+export function buildCandidateList(
+  context: ToolContext,
+  targetClientId?: string,
+): BackendCandidate[] {
   const { conversationId, sourceActorPrincipalId } = context;
   const candidates: BackendCandidate[] = [];
   const hostBrowserProxy = HostBrowserProxy.instance;
@@ -789,7 +798,9 @@ export function buildChainedClient(
     },
 
     dispose(): void {
-      if (disposed) return;
+      if (disposed) {
+        return;
+      }
       disposed = true;
       for (const m of materialisedManagers) {
         m.disposeAll();
@@ -836,7 +847,10 @@ export function buildChainedClient(
       // Fresh client: route through the failover walk so the extension
       // backend is selected automatically. The Vellum.listTabs pseudo-method
       // is handled by the extension dispatcher before chrome.debugger.sendCommand.
-      const result = await scopedClient.send<{ tabs?: TabInfo[] }>("Vellum.listTabs", {});
+      const result = await scopedClient.send<{ tabs?: TabInfo[] }>(
+        "Vellum.listTabs",
+        {},
+      );
       if (!active?.client.listTabs) {
         // Backend became sticky but isn't an extension client — not supported.
         throw new CdpError(
@@ -1312,10 +1326,14 @@ function unwrapResult<T>(
  * "ECONNREFUSED", "DISCOVERY_TIMEOUT") that is useful for diagnostics.
  */
 function extractDiscoveryCode(underlying: unknown): string | undefined {
-  if (underlying == null) return undefined;
+  if (underlying == null) {
+    return undefined;
+  }
   if (typeof underlying === "object" && "code" in underlying) {
     const code = (underlying as Record<string, unknown>).code;
-    if (typeof code === "string") return code;
+    if (typeof code === "string") {
+      return code;
+    }
   }
   if (underlying instanceof Error && "cause" in underlying) {
     return extractDiscoveryCode(underlying.cause);

package/src/tools/browser/cdp-client/local-cdp-client.ts

@@ -60,7 +60,9 @@ export class LocalCdpClient implements ScopedCdpClient {
     if (this.disposed) {
       throw new CdpError("disposed", "LocalCdpClient already disposed");
     }
-    if (this.sessionPromise) return this.sessionPromise;
+    if (this.sessionPromise) {
+      return this.sessionPromise;
+    }
     const created = this.createSession();
     this.sessionPromise = created;
     // Clear the cached promise on rejection so the next call retries
@@ -166,23 +168,36 @@ export class LocalCdpClient implements ScopedCdpClient {
   }
 
   async listTabs(): Promise<never> {
-    throw new CdpError("transport_error", "listTabs is not supported by the local backend (extension backend required)");
+    throw new CdpError(
+      "transport_error",
+      "listTabs is not supported by the local backend (extension backend required)",
+    );
   }
 
   async selectTab(_tabId: number): Promise<never> {
-    throw new CdpError("transport_error", "selectTab is not supported by the local backend (extension backend required)");
+    throw new CdpError(
+      "transport_error",
+      "selectTab is not supported by the local backend (extension backend required)",
+    );
   }
 
   async closeTab(_tabId: number): Promise<never> {
-    throw new CdpError("transport_error", "closeTab is not supported by the local backend (extension backend required)");
+    throw new CdpError(
+      "transport_error",
+      "closeTab is not supported by the local backend (extension backend required)",
+    );
   }
 
   dispose(): void {
-    if (this.disposed) return;
+    if (this.disposed) {
+      return;
+    }
     this.disposed = true;
     const pending = this.sessionPromise;
     this.sessionPromise = null;
-    if (!pending) return;
+    if (!pending) {
+      return;
+    }
     pending
       .then(async (session) => {
         try {

package/src/tools/browser/cdp-client/types.ts

@@ -98,7 +98,11 @@ export interface CdpClient {
  * the sacrificial-profile screencast setup when running against the
  * user's own Chrome via the extension).
  */
-export type CdpClientKind = "local" | "extension" | "cdp-inspect" | "host-bridge";
+export type CdpClientKind =
+  | "local"
+  | "extension"
+  | "cdp-inspect"
+  | "host-bridge";
 
 /**
  * Backend mode preference for the CDP factory. Controls which

package/src/tools/browser/network-recorder.ts

@@ -66,7 +66,9 @@ class DirectCDPClient {
           } else if (msg.method) {
             const handlers = this.eventHandlers.get(msg.method);
             if (handlers) {
-              for (const h of handlers) h(msg.params ?? {});
+              for (const h of handlers) {
+                h(msg.params ?? {});
+              }
             }
           }
         } catch (e) {
@@ -80,7 +82,9 @@ class DirectCDPClient {
     method: string,
     params?: Record<string, unknown>,
   ): Promise<unknown> {
-    if (!this.ws) throw new Error("Not connected");
+    if (!this.ws) {
+      throw new Error("Not connected");
+    }
     const id = this.nextId++;
     return new Promise((resolve, reject) => {
       this.callbacks.set(id, { resolve, reject });
@@ -132,7 +136,9 @@ export class NetworkRecorder {
 
   constructor(targetDomain?: string, cdpBaseUrl?: string) {
     this.targetDomain = targetDomain;
-    if (cdpBaseUrl) this.cdpBaseUrl = cdpBaseUrl;
+    if (cdpBaseUrl) {
+      this.cdpBaseUrl = cdpBaseUrl;
+    }
   }
 
   /**
@@ -140,8 +146,12 @@ export class NetworkRecorder {
    * Attaches to the browser-level target so events from all tabs are captured.
    */
   async startDirect(cdpBaseUrl?: string): Promise<void> {
-    if (this.running) return;
-    if (cdpBaseUrl) this.cdpBaseUrl = cdpBaseUrl;
+    if (this.running) {
+      return;
+    }
+    if (cdpBaseUrl) {
+      this.cdpBaseUrl = cdpBaseUrl;
+    }
 
     // Discover the browser's WebSocket debugger URL
     const versionRes = await fetch(`${this.cdpBaseUrl}/json/version`);
@@ -179,7 +189,9 @@ export class NetworkRecorder {
   }
 
   private async discoverAndAttachTargets(): Promise<void> {
-    if (!this.running) return;
+    if (!this.running) {
+      return;
+    }
     try {
       const res = await fetch(`${this.cdpBaseUrl}/json`);
       const pages = (await res.json()) as Array<{
@@ -233,7 +245,9 @@ export class NetworkRecorder {
   }
 
   async stop(): Promise<NetworkRecordedEntry[]> {
-    if (!this.running) return [];
+    if (!this.running) {
+      return [];
+    }
     this.running = false;
 
     // Stop polling for new tabs
@@ -272,7 +286,9 @@ export class NetworkRecorder {
    */
   async extractCookies(domain?: string): Promise<ExtractedCredential[]> {
     const client = this.pageClients[0];
-    if (!client) return [];
+    if (!client) {
+      return [];
+    }
     try {
       const result = (await client.send("Network.getAllCookies")) as {
         cookies: Array<{
@@ -314,7 +330,9 @@ export class NetworkRecorder {
   }
 
   private matchesDomain(url: string): boolean {
-    if (!this.targetDomain) return true;
+    if (!this.targetDomain) {
+      return true;
+    }
     try {
       const hostname = new URL(url).hostname;
       return (
@@ -330,11 +348,15 @@ export class NetworkRecorder {
 
   private handleRequestWillBeSent(params: Record<string, unknown>): void {
     const resourceType = params.type as string;
-    if (resourceType !== "XHR" && resourceType !== "Fetch") return;
+    if (resourceType !== "XHR" && resourceType !== "Fetch") {
+      return;
+    }
 
     const request = params.request as Record<string, unknown>;
     const url = request.url as string;
-    if (!this.matchesDomain(url)) return;
+    if (!this.matchesDomain(url)) {
+      return;
+    }
 
     const requestId = params.requestId as string;
     const headers = (request.headers as Record<string, string>) ?? {};
@@ -364,7 +386,9 @@ export class NetworkRecorder {
   private handleResponseReceived(params: Record<string, unknown>): void {
     const requestId = params.requestId as string;
     const entry = this.entries.get(requestId);
-    if (!entry) return;
+    if (!entry) {
+      return;
+    }
 
     const response = params.response as Record<string, unknown>;
     const status = (response.status as number) ?? 0;
@@ -398,10 +422,14 @@ export class NetworkRecorder {
   ): void {
     const requestId = params.requestId as string;
     const entry = this.entries.get(requestId);
-    if (!entry || !entry.response) return;
+    if (!entry || !entry.response) {
+      return;
+    }
 
     const mimeType = entry.response.mimeType;
-    if (!mimeType.includes("json") && !mimeType.includes("text")) return;
+    if (!mimeType.includes("json") && !mimeType.includes("text")) {
+      return;
+    }
 
     this.fetchResponseBody(requestId, entry, client);
   }
@@ -411,7 +439,9 @@ export class NetworkRecorder {
     entry: NetworkRecordedEntry,
     client: DirectCDPClient,
   ): Promise<void> {
-    if (!this.running) return;
+    if (!this.running) {
+      return;
+    }
     try {
       const result = (await client.send("Network.getResponseBody", {
         requestId,

package/src/tools/browser/pinned-tabs.ts

@@ -28,7 +28,9 @@ export function setPinnedTab(
   tabId: string,
   clientId?: string,
 ): void {
-  if (!conversationId || !tabId) return;
+  if (!conversationId || !tabId) {
+    return;
+  }
   const key = clientId ?? "__default__";
   let inner = pinnedTabs.get(conversationId);
   if (!inner) {
@@ -54,9 +56,13 @@ export function getPinnedTab(
   conversationId: string,
   clientId?: string,
 ): string | undefined {
-  if (!conversationId) return undefined;
+  if (!conversationId) {
+    return undefined;
+  }
   const inner = pinnedTabs.get(conversationId);
-  if (!inner) return undefined;
+  if (!inner) {
+    return undefined;
+  }
   if (clientId !== undefined) {
     return inner.get(clientId) ?? inner.get("__default__");
   }
@@ -76,14 +82,20 @@ export function clearPinnedTab(
   conversationId: string,
   clientId?: string,
 ): void {
-  if (!conversationId) return;
+  if (!conversationId) {
+    return;
+  }
   const inner = pinnedTabs.get(conversationId);
-  if (!inner) return;
+  if (!inner) {
+    return;
+  }
   if (clientId !== undefined) {
     if (inner.delete(clientId)) {
       log.debug({ conversationId, clientId }, "Cleared pinned extension tab");
     }
-    if (inner.size === 0) pinnedTabs.delete(conversationId);
+    if (inner.size === 0) {
+      pinnedTabs.delete(conversationId);
+    }
   } else {
     // Clear all clients for this conversation
     if (pinnedTabs.delete(conversationId)) {
@@ -106,8 +118,13 @@ export function clearPinnedTab(
  *
  * Returns the number of slots cleared.
  */
-export function clearPinnedTabByTabId(tabId: string, clientId?: string): number {
-  if (!tabId) return 0;
+export function clearPinnedTabByTabId(
+  tabId: string,
+  clientId?: string,
+): number {
+  if (!tabId) {
+    return 0;
+  }
   let cleared = 0;
   for (const [conversationId, inner] of pinnedTabs.entries()) {
     if (clientId !== undefined) {
@@ -133,7 +150,9 @@ export function clearPinnedTabByTabId(tabId: string, clientId?: string): number
         }
       }
     }
-    if (inner.size === 0) pinnedTabs.delete(conversationId);
+    if (inner.size === 0) {
+      pinnedTabs.delete(conversationId);
+    }
   }
   return cleared;
 }

package/src/tools/browser/runtime-check.ts

@@ -21,9 +21,13 @@ export interface BrowserRuntimeStatus {
 function resolveChromium(
   pw: Record<string, unknown>,
 ): Record<string, unknown> | undefined {
-  if (pw.chromium) return pw;
+  if (pw.chromium) {
+    return pw;
+  }
   const def = pw.default as Record<string, unknown> | undefined;
-  if (def?.chromium) return def;
+  if (def?.chromium) {
+    return def;
+  }
   return undefined;
 }
 
@@ -38,7 +42,9 @@ async function tryBundledPlaywright(): Promise<
   try {
     const pw = await import("playwright");
     const mod = resolveChromium(pw as unknown as Record<string, unknown>);
-    if (mod?.chromium) return mod as unknown as typeof import("playwright");
+    if (mod?.chromium) {
+      return mod as unknown as typeof import("playwright");
+    }
   } catch {
     // Bundled import failed entirely
   }
@@ -56,8 +62,12 @@ function resolvePackageEntry(pkgDir: string): string {
     if (typeof exportsRoot === "object" && exportsRoot?.import) {
       return join(pkgDir, exportsRoot.import);
     }
-    if (pkg.module) return join(pkgDir, pkg.module);
-    if (pkg.main) return join(pkgDir, pkg.main);
+    if (pkg.module) {
+      return join(pkgDir, pkg.module);
+    }
+    if (pkg.main) {
+      return join(pkgDir, pkg.main);
+    }
   } catch {
     // Fall through to default
   }
@@ -72,7 +82,9 @@ function resolvePackageEntry(pkgDir: string): string {
 export async function importPlaywright(): Promise<typeof import("playwright")> {
   // Try bundled import (works in dev/source mode)
   const bundled = await tryBundledPlaywright();
-  if (bundled) return bundled;
+  if (bundled) {
+    return bundled;
+  }
 
   // Compiled binary fallback: install playwright to disk and import
   // from an absolute path so the JS runtime resolves it from the
@@ -127,7 +139,9 @@ export async function ensureChromiumHeadlessShell(
 ): Promise<void> {
   try {
     const execPath = pw.chromium.executablePath();
-    if (existsSync(execPath)) return;
+    if (existsSync(execPath)) {
+      return;
+    }
   } catch {
     // executablePath() may throw if the browser registry is missing
   }

package/src/tools/credentials/broker.ts

@@ -441,7 +441,9 @@ export class CredentialBroker {
     const now = Date.now();
     let count = 0;
     for (const token of this.tokens.values()) {
-      if (!token.consumed && now - token.createdAt <= TOKEN_TTL_MS) count++;
+      if (!token.consumed && now - token.createdAt <= TOKEN_TTL_MS) {
+        count++;
+      }
     }
     return count;
   }

package/src/tools/credentials/domain-policy.ts

@@ -25,17 +25,25 @@ export function isDomainAllowed(
   requestHost: string,
   allowedDomains: string[],
 ): boolean {
-  if (!allowedDomains || allowedDomains.length === 0) return false;
+  if (!allowedDomains || allowedDomains.length === 0) {
+    return false;
+  }
 
   const requestInfo = normalizeDomain(requestHost);
-  if (!requestInfo) return false;
+  if (!requestInfo) {
+    return false;
+  }
 
   for (const allowed of allowedDomains) {
     const allowedInfo = normalizeDomain(allowed);
-    if (!allowedInfo) continue;
+    if (!allowedInfo) {
+      continue;
+    }
 
     // Exact hostname match
-    if (requestInfo.hostname === allowedInfo.hostname) return true;
+    if (requestInfo.hostname === allowedInfo.hostname) {
+      return true;
+    }
 
     // Registrable-domain match: request's registrable domain must equal
     // the allowed entry's registrable domain, and the allowed entry

package/src/tools/credentials/host-pattern-match.ts

@@ -31,7 +31,9 @@ export function matchHostPattern(
   const lHost = host.toLowerCase();
   const lPattern = pattern.toLowerCase();
 
-  if (lHost === lPattern) return "exact";
+  if (lHost === lPattern) {
+    return "exact";
+  }
 
   if (lPattern.startsWith("*.")) {
     const suffix = lPattern.slice(1); // ".fal.run"

package/src/tools/credentials/post-connect-hooks.ts

@@ -33,7 +33,9 @@ async function slackWelcomeDM(ctx: PostConnectHookContext): Promise<void> {
     | Record<string, unknown>
     | undefined;
   const installingUserId = authedUser?.id as string | undefined;
-  if (!botToken || !installingUserId) return;
+  if (!botToken || !installingUserId) {
+    return;
+  }
 
   const identity = await authTest(botToken);
   const dmChannel = await conversationsOpen(botToken, installingUserId);
@@ -59,7 +61,9 @@ export async function runPostConnectHook(
   ctx: PostConnectHookContext,
 ): Promise<void> {
   const hook = POST_CONNECT_HOOKS[ctx.service];
-  if (!hook) return;
+  if (!hook) {
+    return;
+  }
 
   try {
     await hook(ctx);

package/src/tools/credentials/resolve.ts

@@ -51,7 +51,9 @@ export function resolveByServiceField(
   field: string,
 ): ResolvedCredential | undefined {
   const metadata = getCredentialMetadata(service, field);
-  if (!metadata) return undefined;
+  if (!metadata) {
+    return undefined;
+  }
   return toResolved(metadata);
 }
 
@@ -63,7 +65,9 @@ export function resolveById(
   credentialId: string,
 ): ResolvedCredential | undefined {
   const metadata = getCredentialMetadataById(credentialId);
-  if (!metadata) return undefined;
+  if (!metadata) {
+    return undefined;
+  }
   return toResolved(metadata);
 }
 
@@ -80,17 +84,25 @@ export function resolveById(
 export function resolveCredentialRef(
   ref: string,
 ): ResolvedCredential | undefined {
-  if (!ref || ref.trim().length === 0) return undefined;
+  if (!ref || ref.trim().length === 0) {
+    return undefined;
+  }
 
   // Try as UUID first
   const byId = resolveById(ref);
-  if (byId) return byId;
+  if (byId) {
+    return byId;
+  }
 
   // Try as service/field
   const slashIndex = ref.indexOf("/");
-  if (slashIndex <= 0 || slashIndex >= ref.length - 1) return undefined;
+  if (slashIndex <= 0 || slashIndex >= ref.length - 1) {
+    return undefined;
+  }
   // Reject refs with more than one slash (e.g. "fal/api/key")
-  if (ref.indexOf("/", slashIndex + 1) !== -1) return undefined;
+  if (ref.indexOf("/", slashIndex + 1) !== -1) {
+    return undefined;
+  }
 
   const service = ref.slice(0, slashIndex);
   const field = ref.slice(slashIndex + 1);
@@ -114,7 +126,9 @@ export function resolveForDomain(hostname: string): ResolvedCredential[] {
           includeApexForWildcard: true,
         }) !== "none",
     );
-    if (matching.length === 0) continue;
+    if (matching.length === 0) {
+      continue;
+    }
     results.push({
       ...toResolved(meta),
       injectionTemplates: matching,

package/src/tools/credentials/selection.ts

@@ -52,13 +52,19 @@ function bestHostMatch(
   templates: CredentialInjectionTemplate[] | undefined,
   targetHost: string,
 ): "exact" | "wildcard" | "none" {
-  if (!templates || templates.length === 0) return "none";
+  if (!templates || templates.length === 0) {
+    return "none";
+  }
 
   let best: "exact" | "wildcard" | "none" = "none";
   for (const t of templates) {
     const match = hostMatchesPattern(targetHost, t.hostPattern);
-    if (match === "exact") return "exact"; // can't do better
-    if (match === "wildcard") best = "wildcard";
+    if (match === "exact") {
+      return "exact";
+    } // can't do better
+    if (match === "wildcard") {
+      best = "wildcard";
+    }
   }
   return best;
 }
@@ -93,7 +99,9 @@ export function rankCredentialsForEndpoint(
   for (const cred of credentials) {
     // Domain policy check using the same matcher as credential enforcement
     if (cred.allowedDomains.length > 0) {
-      if (!isDomainAllowed(targetHost, cred.allowedDomains)) continue;
+      if (!isDomainAllowed(targetHost, cred.allowedDomains)) {
+        continue;
+      }
     }
 
     let tierScore = 0;
@@ -131,7 +139,9 @@ export function rankCredentialsForEndpoint(
   // Sort by tier score first, then by recency as tiebreaker
   scored.sort((a, b) => {
     const tierDiff = b.tierScore - a.tierScore;
-    if (tierDiff !== 0) return tierDiff;
+    if (tierDiff !== 0) {
+      return tierDiff;
+    }
     return b.updatedAt - a.updatedAt;
   });
 

package/src/tools/credentials/tool-policy.ts

@@ -52,8 +52,12 @@ export function isToolAllowed(
   toolName: string,
   allowedTools: string[],
 ): boolean {
-  if (!Array.isArray(allowedTools) || allowedTools.length === 0) return false;
-  if (!toolName || typeof toolName !== "string") return false;
+  if (!Array.isArray(allowedTools) || allowedTools.length === 0) {
+    return false;
+  }
+  if (!toolName || typeof toolName !== "string") {
+    return false;
+  }
 
   const canonical = resolveCanonical(toolName);
   return allowedTools.some(