@vellumai/assistant 0.7.3 → 0.8.1

package/src/daemon/conversation-surfaces.ts

@@ -1159,6 +1159,7 @@ export async function handleSurfaceAction(
       summary,
       submittedData: data,
     });
+    markSurfaceCompleted(ctx, surfaceId, summary);
 
     // Cleanup and resolve — order matters: cleanup clears the timer
     // before resolve() unblocks the caller.
@@ -1505,20 +1506,6 @@ export async function handleSurfaceAction(
     surfaceData,
   );
 
-  // Forms are one-shot surfaces — auto-complete immediately so the client
-  // transitions from the "Submitting…" spinner to a completion chip without
-  // requiring the LLM to call ui_dismiss.
-  if (pending.surfaceType === "form") {
-    broadcastMessage({
-      type: "ui_surface_complete",
-      conversationId: ctx.conversationId,
-      surfaceId,
-      summary,
-      submittedData: mergedData,
-    });
-    markSurfaceCompleted(ctx, surfaceId, summary);
-  }
-
   // Extract file attachments from action data so they are sent as proper
   // image/file content blocks instead of dumping base64 into the text.
   let pendingAttachments: UserMessageAttachment[] = [];
@@ -1648,6 +1635,21 @@ export async function handleSurfaceAction(
     return;
   }
 
+  // One-shot interactive surfaces — auto-complete now that the message has
+  // been accepted. Deferred until after rejection check so the surface stays
+  // active and retryable if the queue was full.
+  const ONE_SHOT_SURFACE_TYPES = ["form", "confirmation", "file_upload"];
+  if (ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)) {
+    broadcastMessage({
+      type: "ui_surface_complete",
+      conversationId: ctx.conversationId,
+      surfaceId,
+      summary,
+      submittedData: mergedDataForText,
+    });
+    markSurfaceCompleted(ctx, surfaceId, summary);
+  }
+
   // One-shot: clear accumulated state now that the message has been accepted.
   // Deferred until after rejection check so state is preserved for retry on rejection.
   if (accumulatedState && Object.keys(accumulatedState).length > 0) {
@@ -2021,14 +2023,6 @@ export async function surfaceProxyResolver(
 
   // Route app-control proxy tools (all app_control_* tool variants)
   if (toolName.startsWith("app_control_")) {
-    if (!ctx.hostAppControlProxy || !ctx.hostAppControlProxy.isAvailable()) {
-      return {
-        content:
-          "App control is not available — enable the `app-control` feature flag and connect a macOS client.",
-        isError: true,
-      };
-    }
-
     // `app_control_stop` resolves immediately: tear down the proxy without
     // a client round-trip. Mirrors CU's terminal-tool short-circuit
     // (`computer_use_done` / `computer_use_respond`). Clear the
@@ -2037,15 +2031,85 @@ export async function surfaceProxyResolver(
     // instead of dispatching against a torn-down proxy, and so a sibling
     // conversation can acquire the released singleton lock without the
     // disposed proxy still being addressable.
+    //
+    // Run this BEFORE the isAvailable() gate so a disconnected client
+    // doesn't strand the singleton lock — stop is local-only.
     if (toolName === "app_control_stop") {
-      if (ctx.setHostAppControlProxy) {
-        ctx.setHostAppControlProxy(undefined);
-      } else {
-        ctx.hostAppControlProxy.dispose();
+      if (ctx.hostAppControlProxy) {
+        if (ctx.setHostAppControlProxy) {
+          ctx.setHostAppControlProxy(undefined);
+        } else {
+          ctx.hostAppControlProxy.dispose();
+        }
       }
       return { content: "App control stopped.", isError: false };
     }
 
+    if (!ctx.hostAppControlProxy || !ctx.hostAppControlProxy.isAvailable()) {
+      return {
+        content:
+          "App control is not available — enable the `app-control` feature flag and connect a macOS client.",
+        isError: true,
+      };
+    }
+
+    // Resolve target client. Mirrors the host_cu block above: validate
+    // explicit target_client_id (existence, capability, same-actor), then
+    // multi-client guard when no target is supplied. App-control is
+    // single-client-only at the host (one active session per macOS
+    // machine), so a broadcast across multiple capable clients would fire
+    // the same input on every machine.
+    let targetClientId: string | undefined =
+      typeof input.target_client_id === "string" &&
+      input.target_client_id !== ""
+        ? input.target_client_id
+        : undefined;
+
+    const sourceActorPrincipalId = ctx.trustContext?.guardianPrincipalId;
+    if (targetClientId != null) {
+      const client = assistantEventHub.getClientById(targetClientId);
+      if (!client) {
+        return {
+          content: `No connected client with id '${targetClientId}'. Run \`assistant clients list --capability host_app_control\` to see available clients.`,
+          isError: true,
+        };
+      }
+      if (!client.capabilities.includes("host_app_control")) {
+        return {
+          content: `Client '${targetClientId}' does not support host_app_control. Run \`assistant clients list --capability host_app_control\` to see available clients.`,
+          isError: true,
+        };
+      }
+      const rejection = enforceSameActorOrErrorResult({
+        hub: assistantEventHub,
+        sourceActorPrincipalId,
+        targetClientId,
+        op: "host_app_control",
+      });
+      if (rejection) return rejection;
+    }
+
+    if (targetClientId == null) {
+      const allAcClients =
+        assistantEventHub.listClientsByCapability("host_app_control");
+      const sameUserAcClients = allAcClients.filter(
+        (c) => c.actorPrincipalId === sourceActorPrincipalId,
+      );
+      if (sameUserAcClients.length > 1) {
+        return {
+          content: `Error: multiple clients support host_app_control. Specify which client to target with \`target_client_id\`. Run \`assistant clients list --capability host_app_control\` to see client IDs and labels.`,
+          isError: true,
+        };
+      }
+      // When cross-user host_app_control clients are connected, auto-
+      // resolve to the unique same-user client. Otherwise the proxy would
+      // dispatch untargeted and the action could reach a cross-user
+      // client. Belt-and-suspenders: the proxy re-checks same-user.
+      if (sameUserAcClients.length === 1 && allAcClients.length > 1) {
+        targetClientId = sameUserAcClients[0].clientId;
+      }
+    }
+
     // The TS `HostAppControlInput` (and the Swift mirror) is a discriminated
     // union on `tool` ("start" | "observe" | "press" | …). The agent's raw
     // tool input only carries the action-specific payload (app, x/y, text,
@@ -2064,6 +2128,8 @@ export async function surfaceProxyResolver(
       inputWithTool,
       ctx.conversationId,
       signal ?? new AbortController().signal,
+      sourceActorPrincipalId,
+      targetClientId,
     );
   }
 

package/src/daemon/conversation-tool-setup.ts

@@ -30,6 +30,7 @@ import {
   ACTIVITY_SKIP_SET,
   injectActivityField,
 } from "../tools/schema-transforms.js";
+import { resolveToolNameAlias } from "../tools/tool-name-aliases.js";
 import {
   isDiskPressureCleanupToolName,
   type ProxyApprovalCallback,
@@ -122,7 +123,9 @@ export function createToolExecutor(
     toolUseId?: string,
     turnContext?: import("../plugins/types.js").TurnContext,
   ) => {
-    if (isDoordashCommand(name, input)) {
+    const executionName = resolveToolNameAlias(name, ctx.allowedToolNames);
+
+    if (isDoordashCommand(executionName, input)) {
       markDoordashStepInProgress(ctx, input);
     }
 
@@ -153,6 +156,7 @@ export function createToolExecutor(
       onOutput,
       signal: ctx.abortController?.signal,
       allowedToolNames: ctx.allowedToolNames,
+      forcePromptSideEffects: ctx.forcePromptSideEffects,
       diskPressureCleanupModeActive: ctx.diskPressureCleanupModeActive,
       toolUseId,
       isPlatformHosted: getIsPlatform(),
@@ -208,8 +212,9 @@ export function createToolExecutor(
     // route through the full executor pipeline so the underlying tool's
     // risk level, permission checks, hooks, and lifecycle events all fire
     // with the real tool name.
-    if (name === "skill_execute") {
-      const toolName = typeof input.tool === "string" ? input.tool : "";
+    if (executionName === "skill_execute") {
+      const rawToolName = typeof input.tool === "string" ? input.tool : "";
+      const toolName = resolveToolNameAlias(rawToolName, ctx.allowedToolNames);
       const rawToolInput =
         input.input != null && typeof input.input === "object"
           ? (input.input as Record<string, unknown>)
@@ -242,7 +247,7 @@ export function createToolExecutor(
     }
 
     const result = await executor.execute(
-      name,
+      executionName,
       input,
       toolContext,
       turnContext,
@@ -251,7 +256,7 @@ export function createToolExecutor(
       ctx.approvedViaPromptThisTurn = true;
     }
 
-    runPostExecutionSideEffects(name, input, result, { ctx });
+    runPostExecutionSideEffects(executionName, input, result, { ctx });
 
     return result;
   };
@@ -357,26 +362,35 @@ export const HOST_TOOL_TO_CAPABILITY = new Map<string, HostProxyCapability>([
 export const HOST_TOOL_NAMES = new Set(HOST_TOOL_TO_CAPABILITY.keys());
 /**
  * Capabilities eligible for cross-client exposure on non-host-proxy
- * transports (e.g. web, ios routing to a connected macOS client).
+ * transports (e.g. web, ios routing to a connected capable client).
  * Adding a capability here exposes ALL tools that map to it (per
  * HOST_TOOL_TO_CAPABILITY) on non-host-proxy transports — the daemon then
  * routes the actual invocation to the connected capable client via the
  * proxy's targetClientId path.
  *
+ * All members below adopt the same-actor enforcement pattern: the proxy
+ * binds the request to a specific client id + actor principal id at
+ * dispatch time, and the corresponding result route requires the
+ * submitting client to present an `x-vellum-client-id` matching the
+ * captured target plus an `x-vellum-actor-principal-id` matching the
+ * captured actor (see `enforceSameActorOrThrow` in
+ * `runtime/auth/same-actor.ts`).
+ *
  * Inclusions:
  * - host_bash (Phase 1, PR #29322)
  * - host_file (Phases 2 & 3, PRs #29398 + #29440)
+ * - host_browser (PR #27489 executor parity + PR #29829 cross-client
+ *   exposure with same-actor guard at proxy dispatch and result route)
  *
  * Exclusions:
- * - host_browser: chrome-extension is its own executor; web turns don't
- *   have a CDP target model. Re-evaluate when host browser via macOS
- *   host proxy ships (PR #27489).
- * - host_app_control, host_cu: not in HOST_TOOL_TO_CAPABILITY
- *   (skill-routed).
+ * - host_app_control, host_cu: not in HOST_TOOL_TO_CAPABILITY (skill-routed).
+ *   Their cross-client exposure is handled at the skill preactivation layer
+ *   via `preactivateHostProxySkills` — see host-proxy-preactivation.ts.
  */
 const CROSS_CLIENT_EXPOSED_CAPABILITIES = new Set<HostProxyCapability>([
   "host_bash",
   "host_file",
+  "host_browser",
 ]);
 const CLIENT_CAPABILITY_TOOL_NAMES = new Set(["app_open"]);
 const PLATFORM_TOOL_NAMES = new Set(["request_system_permission"]);
@@ -413,15 +427,15 @@ export function isToolActiveForContext(
     // transport cannot service this capability, the tool is filtered out.
     if (transport && capability && !supportsHostProxy(transport, capability)) {
       // Cross-client exception: allow host tools whose capabilities have
-      // cross-client routing infrastructure (Phases 1–3) to be exposed for
-      // non-host-proxy transports (e.g. "web", "ios") when at least one
-      // capable client is connected via the event hub. Members of
-      // CROSS_CLIENT_EXPOSED_CAPABILITIES (host_bash, host_file) qualify;
-      // host_browser is intentionally excluded (chrome-extension is its
-      // own executor and web turns don't have a CDP target model).
+      // cross-client routing infrastructure (Phases 1–3 plus host_browser
+      // via PR #27489) to be exposed for non-host-proxy transports (e.g.
+      // "web", "ios") when at least one capable client is connected via
+      // the event hub. Members of CROSS_CLIENT_EXPOSED_CAPABILITIES
+      // (host_bash, host_file, host_browser) qualify.
       // chrome-extension transport is excluded as a security boundary
-      // (extension only gets host_browser); hasNoClient turns are excluded
-      // (no interactive approval UI available).
+      // (extension only gets host_browser via its own executor path);
+      // hasNoClient turns are excluded (no interactive approval UI
+      // available).
       if (
         capability &&
         CROSS_CLIENT_EXPOSED_CAPABILITIES.has(capability) &&

package/src/daemon/conversation.ts

@@ -27,6 +27,7 @@ import {
   contextWindowConfigFromEffective,
   resolveEffectiveContextWindow,
 } from "../config/llm-context-resolution.js";
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../config/types.js";
@@ -53,6 +54,7 @@ import {
   getConversationOriginChannel,
   getConversationOverrideProfileFromRow,
 } from "../memory/conversation-crud.js";
+import { isBackgroundConversationType } from "../memory/conversation-types.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
@@ -119,8 +121,9 @@ import {
 } from "./conversation-tool-setup.js";
 import { refreshWorkspaceTopLevelContextIfNeeded as refreshWorkspaceImpl } from "./conversation-workspace.js";
 import { canonicalizeTimeZone } from "./date-context.js";
-import type { HostAppControlProxy } from "./host-app-control-proxy.js";
+import { HostAppControlProxy } from "./host-app-control-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
+import { shouldAttachHostProxyForCapability } from "./host-proxy-preactivation.js";
 import type {
   ServerMessage,
   SurfaceData,
@@ -233,6 +236,14 @@ export class Conversation {
   };
   /** @internal */ surfaceActionRequestIds = new Set<string>();
   /** @internal */ approvedViaPromptThisTurn = false;
+  /**
+   * When true, side-effect tools must prompt even if a trust/allow rule
+   * would auto-allow. Set by non-interactive callers (e.g. non-guardian
+   * phone voice) so their auto-deny handler reliably sees a
+   * `confirmation_request` event. See ToolSetupContext.forcePromptSideEffects.
+   * @internal
+   */
+  forcePromptSideEffects = false;
   /** @internal */ pendingSurfaceActions = new Map<
     string,
     { surfaceType: SurfaceType }
@@ -424,7 +435,8 @@ export class Conversation {
     );
 
     const config = getConfig();
-    this.streamThinking = config.llm.default.thinking.streamThinking ?? false;
+    const resolvedMainAgent = resolveCallSiteConfig("mainAgent", config.llm);
+    this.streamThinking = resolvedMainAgent.thinking.streamThinking ?? false;
 
     // CES (Credential Execution Service) — use the shared server-level client.
     // The CES sidecar accepts exactly one bootstrap connection, so the
@@ -463,6 +475,9 @@ export class Conversation {
                 channelPersona: persona.channelPersona,
                 userSlug: persona.userSlug,
                 onboardingContext: this.getOnboardingContext(),
+                isBackgroundConversation: isBackgroundConversationType(
+                  getConversation(this.conversationId)?.conversationType,
+                ),
               });
             })(),
       };
@@ -476,20 +491,19 @@ export class Conversation {
     };
 
     const fastModeEnabled = isAssistantFeatureFlagEnabled("fast-mode", config);
-    const resolvedSpeed = speedOverride ?? config.llm.default.speed;
-    const llmDefault = config.llm.default;
+    const resolvedSpeed = speedOverride ?? resolvedMainAgent.speed;
     const initialContextWindow = resolveEffectiveContextWindow({
       llm: config.llm,
       callSite: "mainAgent",
     });
     const initialContextWindowConfig = contextWindowConfigFromEffective(
-      llmDefault.contextWindow,
+      resolvedMainAgent.contextWindow,
       initialContextWindow,
     );
 
     const agentLoopConfig: Partial<AgentLoopConfig> = {
-      thinking: llmDefault.thinking,
-      effort: llmDefault.effort,
+      thinking: resolvedMainAgent.thinking,
+      effort: resolvedMainAgent.effort,
       ...(fastModeEnabled && resolvedSpeed === "fast"
         ? { speed: resolvedSpeed }
         : {}),
@@ -551,6 +565,9 @@ export class Conversation {
             channelPersona: persona.channelPersona,
             userSlug: persona.userSlug,
             onboardingContext: this.getOnboardingContext(),
+            isBackgroundConversation: isBackgroundConversationType(
+              getConversation(this.conversationId)?.conversationType,
+            ),
           });
         })();
     const tools = buildToolDefinitions();
@@ -943,6 +960,23 @@ export class Conversation {
     this.hostAppControlProxy = proxy;
   }
 
+  ensureHostProxiesForTurn(
+    sourceInterface: import("../channels/types.js").InterfaceId | undefined,
+  ): void {
+    if (
+      shouldAttachHostProxyForCapability("host_cu", sourceInterface) &&
+      !this.hostCuProxy
+    ) {
+      this.setHostCuProxy(new HostCuProxy());
+    }
+    if (
+      shouldAttachHostProxyForCapability("host_app_control", sourceInterface) &&
+      !this.hostAppControlProxy
+    ) {
+      this.setHostAppControlProxy(new HostAppControlProxy(this.conversationId));
+    }
+  }
+
   // ── Server-authoritative state signals ─────────────────────────────
 
   emitConfirmationStateChanged(
@@ -991,7 +1025,9 @@ export class Conversation {
     }
   }
 
-  async forceCompact(): Promise<ContextWindowResult> {
+  async forceCompact(options?: {
+    targetInputTokensOverride?: number;
+  }): Promise<ContextWindowResult> {
     const conversationRow = getConversation(this.conversationId);
     const overrideProfile =
       getConversationOverrideProfileFromRow(conversationRow) ?? null;
@@ -1007,7 +1043,9 @@ export class Conversation {
       }
     ).updateConfig?.(
       contextWindowConfigFromEffective(
-        config.llm.default.contextWindow,
+        resolveCallSiteConfig("mainAgent", config.llm, {
+          overrideProfile: overrideProfile ?? undefined,
+        }).contextWindow,
         effectiveContextWindow,
       ),
     );
@@ -1037,6 +1075,7 @@ export class Conversation {
         conversationOriginChannel:
           getConversationOriginChannel(this.conversationId) ?? undefined,
         overrideProfile,
+        targetInputTokensOverride: options?.targetInputTokensOverride,
       },
     );
     // Track circuit-breaker state for user-initiated `/compact` and other
@@ -1052,7 +1091,7 @@ export class Conversation {
       );
     }
     if (result.compacted) {
-      applyCompactionResult(this, result, this.sendToClient, null, {
+      await applyCompactionResult(this, result, this.sendToClient, null, {
         slackContextCompactionWatermarkTs: getSlackCompactionWatermarkForPrefix(
           slackChronologicalContext,
           result.compactedMessages,

package/src/daemon/external-plugins-bootstrap.ts

@@ -69,6 +69,7 @@ import {
   type Plugin,
   PluginExecutionError,
   type PluginInitContext,
+  type PluginShutdownContext,
   type PluginSkillRegistration,
 } from "../plugins/types.js";
 import {
@@ -218,8 +219,16 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
   // server), the latter drops the plugin's entry from the Map (so
   // `getMiddlewaresFor` / `getInjectors` don't re-enter an uninitialized
   // plugin on the next pipeline invocation).
+  // Shutdown context is identical for every plugin in this boot — construct
+  // once and reuse across the bootstrap-failure rollback and the normal
+  // shutdown hook below. Only `assistantVersion` is exposed today; future
+  // additions live on {@link PluginShutdownContext}.
+  const shutdownContext: PluginShutdownContext = {
+    assistantVersion: ctx.assistantVersion,
+  };
+
   async function rollbackPlugin(active: ActivePlugin): Promise<void> {
-    await teardownPlugin(active, "bootstrap-failed");
+    await teardownPlugin(active, "bootstrap-failed", shutdownContext);
     unregisterPlugin(active.plugin.manifest.name);
   }
 
@@ -309,9 +318,9 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
         apiVersions: ASSISTANT_API_VERSIONS,
       };
 
-      if (plugin.init) {
+      if (plugin.hooks?.init) {
         try {
-          await plugin.init(initContext);
+          await plugin.hooks.init(initContext);
         } catch (err) {
           throw new PluginExecutionError(
             `plugin ${name} init() failed: ${
@@ -445,7 +454,7 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
   const shutdownSnapshot: ActivePlugin[] = [...activePlugins];
   registerShutdownHook("plugins", async (reason) => {
     for (let i = shutdownSnapshot.length - 1; i >= 0; i--) {
-      await teardownPlugin(shutdownSnapshot[i]!, reason);
+      await teardownPlugin(shutdownSnapshot[i]!, reason, shutdownContext);
     }
   });
 }
@@ -473,6 +482,7 @@ interface ActivePlugin {
 async function teardownPlugin(
   active: ActivePlugin,
   reason: string,
+  shutdownContext: PluginShutdownContext,
 ): Promise<void> {
   const { plugin, routeHandles } = active;
   const name = plugin.manifest.name;
@@ -504,17 +514,17 @@ async function teardownPlugin(
     );
   }
 
-  if (plugin.onShutdown) {
+  if (plugin.hooks?.shutdown) {
     try {
-      await plugin.onShutdown();
+      await plugin.hooks.shutdown(shutdownContext);
     } catch (err) {
-      // Swallow — we want every plugin's onShutdown to get a chance to run
+      // Swallow — we want every plugin's shutdown to get a chance to run
       // even when an earlier one throws. The outer runShutdownHooks already
       // logs at hook level, but the plugin-name attribution here is what
       // operators read first.
       log.warn(
         { err, plugin: name, reason },
-        "plugin onShutdown failed (continuing with remaining plugins)",
+        "plugin shutdown hook failed (continuing with remaining plugins)",
       );
     }
   }

package/src/daemon/guardian-action-generators.ts

@@ -1,7 +1,6 @@
-import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
+import { loadConfig } from "../config/loader.js";
+import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
 import { getConfiguredProvider } from "../providers/provider-send-message.js";
-import { getProvider } from "../providers/registry.js";
-import type { Provider } from "../providers/types.js";
 import {
   buildGuardianActionGenerationPrompt,
   getGuardianActionFallbackMessage,
@@ -32,8 +31,10 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
     if (!baseProvider) return null;
     // Wrap so the per-call `callSite` can route to a different provider
     // transport when `llm.callSites.guardianQuestionCopy.provider` overrides
-    // the default. Without this, callSite only affects request metadata.
-    const provider = wrapWithCallSiteRouting(baseProvider);
+    // the default. Connection-aware: when the resolved profile names a
+    // `provider_connection`, that connection's auth wins over the legacy
+    // registry lookup. See `wrapWithCallSiteRouting`.
+    const provider = wrapWithCallSiteRouting(baseProvider, loadConfig());
 
     const fallbackText =
       options.fallbackText?.trim() || getGuardianActionFallbackMessage(context);
@@ -135,7 +136,7 @@ export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpC
     if (!baseProvider) {
       throw new Error("No configured provider available for follow-up conversation");
     }
-    const provider = wrapWithCallSiteRouting(baseProvider);
+    const provider = wrapWithCallSiteRouting(baseProvider, loadConfig());
 
     const userPrompt = [
       `Original question from the voice call: "${context.questionText}"`,
@@ -192,19 +193,3 @@ export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpC
     return result;
   };
 }
-
-/**
- * Wrap a base Provider so per-call `callSite` metadata can route the actual
- * transport to a different provider when `llm.callSites.<id>.provider`
- * differs from the default. Without this wrapper, only request metadata
- * reflects the callSite — the HTTP transport stays bound to the default.
- */
-function wrapWithCallSiteRouting(base: Provider): Provider {
-  return new CallSiteRoutingProvider(base, (name) => {
-    try {
-      return getProvider(name);
-    } catch {
-      return undefined;
-    }
-  });
-}