@vellumai/assistant 0.8.0 → 0.8.1

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

@@ -156,6 +156,7 @@ export function createToolExecutor(
       onOutput,
       signal: ctx.abortController?.signal,
       allowedToolNames: ctx.allowedToolNames,
+      forcePromptSideEffects: ctx.forcePromptSideEffects,
       diskPressureCleanupModeActive: ctx.diskPressureCleanupModeActive,
       toolUseId,
       isPlatformHosted: getIsPlatform(),
@@ -361,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"]);
@@ -417,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

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;
-    }
-  });
-}

package/src/daemon/handlers/config-model.ts

@@ -1,38 +1,16 @@
+import { resolveCallSiteConfig } from "../../config/llm-resolver.js";
 import {
   getConfig,
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import {
-  setLlmDefaultField,
-  setServiceField,
-} from "../../config/raw-config-utils.js";
-import { VALID_INFERENCE_PROVIDERS } from "../../config/schemas/services.js";
+import { setServiceField } from "../../config/raw-config-utils.js";
 import { providerForImageModelPrefix } from "../../media/types.js";
 import type { ProviderCatalogEntry } from "../../providers/model-catalog.js";
-import {
-  isModelInCatalog,
-  PROVIDER_CATALOG,
-} from "../../providers/model-catalog.js";
-import { getProviderDefaultModel } from "../../providers/model-intents.js";
-import {
-  getConfiguredProviders,
-  isProviderAvailable,
-} from "../../providers/provider-availability.js";
-import { initializeProviders } from "../../providers/registry.js";
-import {
-  conversationEntries,
-  deleteConversation,
-} from "../conversation-store.js";
+import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
+import { getConfiguredProviders } from "../../providers/provider-availability.js";
 import { CONFIG_RELOAD_DEBOUNCE_MS, log } from "./shared.js";
 
-/** Reverse lookup: model ID → provider, derived from PROVIDER_CATALOG. */
-const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
-  PROVIDER_CATALOG.flatMap((provider) =>
-    provider.models.map(({ id }) => [id, provider.id]),
-  ),
-);
-
 // ---------------------------------------------------------------------------
 // Shared business logic (transport-agnostic)
 // ---------------------------------------------------------------------------
@@ -85,10 +63,11 @@ export function projectProviderForWire(
 /** Return current model configuration. */
 export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
-  const provider = config.llm.default.provider;
+  const resolved = resolveCallSiteConfig("mainAgent", config.llm);
+  const provider = resolved.provider;
 
   return {
-    model: config.llm.default.model,
+    model: resolved.model,
     provider,
     configuredProviders: await getConfiguredProviders(),
     availableModels: PROVIDER_CATALOG.find(
@@ -99,7 +78,7 @@ export async function getModelInfo(): Promise<ModelInfo> {
 }
 
 /**
- * Minimal interface for the side-effects needed by setModel / setImageGenModel.
+ * Minimal interface for the side-effects needed by setImageGenModel.
  * Keeps the business logic decoupled from transport-specific server context.
  */
 export interface ModelSetContext {
@@ -109,103 +88,6 @@ export interface ModelSetContext {
   debounceTimers: { schedule(key: string, fn: () => void, ms: number): void };
 }
 
-/**
- * Set the active model. Returns the resulting ModelInfo, or throws on failure.
- * The caller is responsible for sending the response to the client.
- *
- * When `explicitProvider` is supplied, it takes precedence over automatic
- * provider inference from the model ID. If the provider changes and the
- * current model doesn't belong to the new provider's catalog, the model
- * is auto-reset to the provider's default.
- */
-export async function setModel(
-  modelId: string,
-  ctx: ModelSetContext,
-  explicitProvider?: string,
-): Promise<ModelInfo> {
-  const validProviders = new Set<string>(VALID_INFERENCE_PROVIDERS);
-
-  // Validate explicit provider against allowlist
-  if (explicitProvider && !validProviders.has(explicitProvider)) {
-    throw new Error(
-      `Invalid provider "${explicitProvider}". Valid providers: ${[...validProviders].join(", ")}`,
-    );
-  }
-
-  // Resolve provider: explicit > MODEL_TO_PROVIDER lookup > current
-  const current = getConfig();
-  const resolvedProvider =
-    explicitProvider ??
-    MODEL_TO_PROVIDER[modelId] ??
-    current.llm.default.provider;
-
-  // Auto-reset model when provider changes and current modelId doesn't
-  // belong to the new provider's catalog.
-  if (
-    resolvedProvider !== current.llm.default.provider &&
-    !isModelInCatalog(resolvedProvider, modelId)
-  ) {
-    modelId = getProviderDefaultModel(resolvedProvider);
-  }
-
-  // No-op guard: skip expensive reinitialization when nothing changed
-  if (
-    modelId === current.llm.default.model &&
-    resolvedProvider === current.llm.default.provider
-  ) {
-    return await getModelInfo();
-  }
-
-  // Validate provider availability (secure key, env var, or managed proxy) before switching
-  if (!(await isProviderAvailable(resolvedProvider))) {
-    // Return current model_info so the client resyncs its optimistic state
-    return await getModelInfo();
-  }
-
-  // Use raw config to avoid persisting env-var API keys to disk
-  const raw = loadRawConfig();
-  setLlmDefaultField(raw, "model", modelId);
-  setLlmDefaultField(raw, "provider", resolvedProvider);
-
-  // Suppress the file watcher callback — setModel already does
-  // the full reload sequence; a redundant watcher-triggered reload
-  // would incorrectly evict sessions created after this method returns.
-  const wasSuppressed = ctx.suppressConfigReload;
-  ctx.setSuppressConfigReload(true);
-  try {
-    saveRawConfig(raw);
-  } catch (err) {
-    ctx.setSuppressConfigReload(wasSuppressed);
-    throw err;
-  }
-  ctx.debounceTimers.schedule(
-    "__suppress_reset__",
-    () => {
-      ctx.setSuppressConfigReload(false);
-    },
-    CONFIG_RELOAD_DEBOUNCE_MS,
-  );
-
-  // Re-initialize provider with the new model so LLM calls use it
-  const config = getConfig();
-  await initializeProviders(config);
-
-  // Evict idle conversations immediately; mark busy ones as stale so they
-  // get recreated with the new provider once they finish processing.
-  for (const [id, conversation] of conversationEntries()) {
-    if (!conversation.isProcessing()) {
-      conversation.dispose();
-      deleteConversation(id);
-    } else {
-      conversation.markStale();
-    }
-  }
-
-  ctx.updateConfigFingerprint();
-
-  return await getModelInfo();
-}
-
 /**
  * Set the image generation model. Throws on failure.
  */

package/src/daemon/handlers/config-slack-channel.ts

@@ -54,6 +54,7 @@ const SLACK_INJECTION_TEMPLATES = [
 /** Ensure the bot token credential has injection templates for the proxy. */
 function ensureBotTokenInjectionTemplates(): void {
   upsertCredentialMetadata("slack_channel", "bot_token", {
+    allowedTools: ["bash"],
     allowedDomains: ["slack.com"],
     injectionTemplates: SLACK_INJECTION_TEMPLATES,
   });
@@ -62,6 +63,7 @@ function ensureBotTokenInjectionTemplates(): void {
 /** Ensure the user token credential has injection templates for the proxy. */
 function ensureUserTokenInjectionTemplates(): void {
   upsertCredentialMetadata("slack_channel", "user_token", {
+    allowedTools: ["bash"],
     allowedDomains: ["slack.com"],
     injectionTemplates: SLACK_INJECTION_TEMPLATES,
   });
@@ -209,7 +211,9 @@ export async function setSlackChannelConfig(
       botToken,
     );
     if (!stored) {
-      return currentErrorSnapshot("Failed to store bot token in secure storage");
+      return currentErrorSnapshot(
+        "Failed to store bot token in secure storage",
+      );
     }
 
     ensureBotTokenInjectionTemplates();
@@ -262,8 +266,7 @@ export async function setSlackChannelConfig(
           data.team_id !== metadata.teamId
         ) {
           shouldClear = true;
-          clearReason =
-            "User token from a different workspace was removed.";
+          clearReason = "User token from a different workspace was removed.";
         }
       } catch (err) {
         // Transient failure (DNS error, network blip, connection reset,
@@ -310,7 +313,9 @@ export async function setSlackChannelConfig(
       appToken,
     );
     if (!stored) {
-      return currentErrorSnapshot("Failed to store app token in secure storage");
+      return currentErrorSnapshot(
+        "Failed to store app token in secure storage",
+      );
     }
 
     upsertCredentialMetadata("slack_channel", "app_token", {});
@@ -344,9 +349,7 @@ export async function setSlackChannelConfig(
       userTeamId = data.team_id;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      return currentErrorSnapshot(
-        `Failed to validate user token: ${message}`,
-      );
+      return currentErrorSnapshot(`Failed to validate user token: ${message}`);
     }
 
     // Cross-check: if a bot token has already been configured, the user token

package/src/daemon/handlers/config-vercel.ts

@@ -59,7 +59,9 @@ export async function setVercelConfig(
   }
 
   upsertCredentialMetadata("vercel", "api_token", {
-    allowedTools: ["deploy", "publish_page"],
+    allowedTools: ["publish_page", "unpublish_page"],
+    allowedDomains: [],
+    injectionTemplates: null,
   });
 
   log.info("Vercel API token stored successfully");