@vellumai/assistant 0.8.0 → 0.8.2

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

@@ -29,15 +29,22 @@
  *    through untouched).
  * 6. Creates `<workspaceDir>/plugins-data/<plugin>/` on demand for per-plugin
  *    writable state and exposes it via {@link PluginInitContext.pluginStorageDir}.
- * 7. Awaits `plugin.init(ctx)` sequentially. One init failure surfaces as a
+ * 7. For each surviving plugin, registers its contributed tools, routes,
+ *    and skills into their global registries via
+ *    {@link registerPluginTools}, {@link registerSkillRoute}, and
+ *    {@link registerPluginSkills}. Contributions land BEFORE `init()` so
+ *    the plugin's hook can observe a registry where its own model-visible
+ *    surface is already wired — useful for plugins that want to attach
+ *    metadata, warm caches, or otherwise interact with their own
+ *    contributions during initialization.
+ * 8. Awaits `plugin.init(ctx)` sequentially. An init failure surfaces as a
  *    {@link PluginExecutionError} naming the offending plugin and aborts
  *    bootstrap — later plugins' `init()` never runs and the daemon fails
- *    startup cleanly rather than coming up in a half-wired state.
- * 8. After a plugin's `init()` succeeds, registers any tools declared on
- *    `plugin.tools` with the global tool registry via
- *    {@link registerPluginTools}. Tool contributions land after `init()` so
- *    a plugin that fails mid-init never leaves partial tool registrations
- *    behind.
+ *    startup cleanly rather than coming up in a half-wired state. The
+ *    failing plugin's already-registered tools, routes, and skills are
+ *    rolled back before the error propagates so the registry never
+ *    carries state contributed by a plugin that never finished
+ *    initializing.
  *
  * A single shutdown hook is registered via
  * {@link registerShutdownHook} that walks the plugin list in **reverse
@@ -54,21 +61,25 @@ import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/schema.js";
+import { HOOKS } from "../plugin-api/constants.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
+import { buildExternalPlugin } from "../plugins/external-plugin-loader.js";
 import {
   registerPluginSkills,
   unregisterPluginSkills,
 } from "../plugins/plugin-skill-contributions.js";
 import {
-  ASSISTANT_API_VERSIONS,
+  getRegisteredPlugin,
   getRegisteredPlugins,
+  setRegisteredPlugin,
   unregisterPlugin,
 } from "../plugins/registry.js";
 import {
   type Plugin,
   PluginExecutionError,
-  type PluginInitContext,
+  type PluginShutdownContext,
   type PluginSkillRegistration,
 } from "../plugins/types.js";
 import {
@@ -83,6 +94,7 @@ import {
 } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
+import { APP_VERSION } from "../version.js";
 import { registerShutdownHook } from "./shutdown-registry.js";
 
 const log = getLogger("plugins-bootstrap");
@@ -169,6 +181,16 @@ function ensurePluginStorageDir(pluginName: string): string {
   return dir;
 }
 
+function getDisabledPluginFlag(
+  plugin: Plugin,
+  config: AssistantConfig,
+): string | undefined {
+  for (const flagKey of plugin.manifest.requiresFlag ?? []) {
+    if (!isAssistantFeatureFlagEnabled(flagKey, config)) return flagKey;
+  }
+  return undefined;
+}
+
 /**
  * Run every registered plugin's `init()` hook sequentially and install a
  * reverse-order shutdown hook. See the module docstring for full semantics.
@@ -218,8 +240,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);
   }
 
@@ -236,187 +266,20 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
   for (const plugin of plugins) {
     const name = plugin.manifest.name;
-
-    // Feature-flag gating — if any key in `manifest.requiresFlag` is
-    // disabled, skip this plugin entirely. Skipping means: no `init()`, no
-    // tool / route / skill contributions, and no shutdown hook entry. A
-    // later boot with the flag flipped ON picks up the plugin cleanly.
-    const requiredFlags = plugin.manifest.requiresFlag ?? [];
-    let disabledFlag: string | undefined;
-    for (const flagKey of requiredFlags) {
-      if (!isAssistantFeatureFlagEnabled(flagKey, ctx.config)) {
-        disabledFlag = flagKey;
-        break;
-      }
-    }
+    const disabledFlag = getDisabledPluginFlag(plugin, ctx.config);
     if (disabledFlag !== undefined) {
       log.info(
         { plugin: name, flag: disabledFlag },
         `skipping plugin ${name}: feature flag ${disabledFlag} is disabled`,
       );
-      // Drop the plugin from the registry too. `registerPlugin()` added it at
-      // import time, and `getMiddlewaresFor()` / `getInjectors()` iterate over
-      // every registered entry — without this call, the gated plugin's
-      // middleware and injectors would still participate in every pipeline
-      // run and system-prompt assembly despite `init()` never firing.
       unregisterPlugin(name);
       continue;
     }
 
-    // Collected as routes are accepted so the catch block can revoke exactly
-    // the routes this plugin contributed if a later contribution step throws.
-    // Hoisted above the try so it's in scope for the error path.
-    const routeHandles: SkillRouteHandle[] = [];
-
-    // Tracks whether `plugin.init()` ran to completion (or the plugin has no
-    // init at all). The catch block consults this to decide whether the
-    // currently-failing plugin's `onShutdown()` may run: onShutdown is paired
-    // with init, so a plugin that never completed init never set up the state
-    // onShutdown is meant to tear down. Calling onShutdown in that case would
-    // surprise plugin authors (their teardown runs against an uninitialized
-    // self) and breaks the documented lifecycle contract.
-    let initCompleted = false;
-
     try {
-      // Credential resolution — gather every entry in `requiresCredential`
-      // before calling `init()` so the plugin receives a fully-populated map.
-      const credentials: Record<string, string> = {};
-      const required = plugin.manifest.requiresCredential ?? [];
-      for (const key of required) {
-        credentials[key] = await resolveCredentialOrThrow(name, key);
-      }
-
-      // Per-plugin config block, validated against the manifest's parser-like
-      // validator when one is declared.
-      const rawConfig = getPluginConfigRaw(ctx.config, name);
-      const config = validatePluginConfig(
-        name,
-        plugin.manifest.config,
-        rawConfig,
-      );
-
-      // Per-plugin writable data directory. Created lazily during bootstrap
-      // rather than at registration time so the side effect is isolated to
-      // the boot path.
-      const pluginStorageDir = ensurePluginStorageDir(name);
-
-      const initContext: PluginInitContext = {
-        config,
-        credentials,
-        logger: log.child({ plugin: name }),
-        pluginStorageDir,
-        assistantVersion: ctx.assistantVersion,
-        apiVersions: ASSISTANT_API_VERSIONS,
-      };
-
-      if (plugin.init) {
-        try {
-          await plugin.init(initContext);
-        } catch (err) {
-          throw new PluginExecutionError(
-            `plugin ${name} init() failed: ${
-              err instanceof Error ? err.message : String(err)
-            }`,
-            name,
-            { cause: err },
-          );
-        }
-      }
-      // Reached when init() succeeded or the plugin has no init hook. The
-      // catch block reads this to decide whether onShutdown may run.
-      initCompleted = true;
-
-      // After init succeeds, wire in the plugin's model-visible capabilities.
-      // Tool contributions (PR 31) register only after `init()` succeeds so a
-      // plugin that fails mid-init never leaves partially-wired tools behind.
-      // Tool registration failures are wrapped in a PluginExecutionError so
-      // the offending plugin name surfaces in the abort — matching the
-      // strict-fail semantics of `init()` errors.
-      if (plugin.tools && plugin.tools.length > 0) {
-        try {
-          const accepted = registerPluginTools(name, plugin.tools);
-          log.info(
-            { plugin: name, count: accepted.length },
-            "plugin tools registered",
-          );
-        } catch (err) {
-          throw new PluginExecutionError(
-            `plugin ${name} tool registration failed: ${
-              err instanceof Error ? err.message : String(err)
-            }`,
-            name,
-            { cause: err },
-          );
-        }
-      }
-
-      // Route contributions (PR 32) — registered after init() succeeds so a
-      // plugin that fails to initialize never exposes a half-wired HTTP
-      // surface. Mirrors the skill-route registry shape; see
-      // {@link PluginRouteRegistration}. Retain every returned handle so the
-      // teardown path unregisters by identity rather than pattern text — two
-      // plugins (or a plugin and a skill) that happen to register the same
-      // regex must not evict each other's routes during shutdown.
-      if (plugin.routes && plugin.routes.length > 0) {
-        for (const route of plugin.routes) {
-          routeHandles.push(registerSkillRoute(route));
-        }
-        log.info(
-          { plugin: name, count: plugin.routes.length },
-          "plugin routes registered",
-        );
-      }
-
-      // Skills register into the in-memory plugin-skill catalog so
-      // `skill_load` / `skill_execute` can resolve them alongside filesystem
-      // skills. A registration failure aborts bootstrap with the plugin named
-      // — same strict-fail posture as init() throws.
-      if (plugin.skills && plugin.skills.length > 0) {
-        try {
-          // `plugin.skills` is typed as `PluginSkillRegistration[]` at the
-          // Plugin interface — the type assertion here is a narrowing from
-          // that generic slot into the concrete shape the registry expects.
-          registerPluginSkills(
-            name,
-            plugin.skills as readonly PluginSkillRegistration[],
-          );
-        } catch (err) {
-          throw new PluginExecutionError(
-            `plugin ${name} skill registration failed: ${
-              err instanceof Error ? err.message : String(err)
-            }`,
-            name,
-            { cause: err },
-          );
-        }
-      }
-
-      activePlugins.push({ plugin, routeHandles });
-
-      log.info({ plugin: name }, "plugin initialized");
+      activePlugins.push(await initializePlugin(plugin, ctx));
     } catch (err) {
-      // Roll back the currently-failing plugin first — it is not in
-      // `activePlugins` yet (that push happens only after every contribution
-      // step succeeds), so `teardownPartialInit()` alone would leave its
-      // already-registered tools, routes, and skills live.
-      //
-      // Branching on `initCompleted` keeps the init/onShutdown pairing
-      // intact. When init succeeded but a later contribution step (tools,
-      // routes, skills) threw, the plugin has live init-side state that
-      // `onShutdown()` is responsible for cleaning up, so the full
-      // rollbackPlugin() path runs. When init itself failed (or a step
-      // before init — credential resolution, config validation — threw),
-      // onShutdown must not run: calling it would invoke the plugin's
-      // teardown against an uninitialized self, violating the lifecycle
-      // contract documented on `Plugin.onShutdown`. In the init-failed case
-      // there is also nothing to unregister — tools, routes, and skills are
-      // all registered after init — so just drop the plugin from the
-      // registry (idempotent if already removed).
-      if (initCompleted) {
-        await rollbackPlugin({ plugin, routeHandles });
-      } else {
-        unregisterPlugin(name);
-      }
+      unregisterPlugin(name);
       await teardownPartialInit();
       throw err;
     }
@@ -445,7 +308,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);
     }
   });
 }
@@ -461,6 +324,114 @@ interface ActivePlugin {
   readonly routeHandles: readonly SkillRouteHandle[];
 }
 
+async function initializePlugin(
+  plugin: Plugin,
+  ctx: DaemonContext,
+): Promise<ActivePlugin> {
+  const name = plugin.manifest.name;
+  const routeHandles: SkillRouteHandle[] = [];
+  let initCompleted = false;
+
+  try {
+    const credentials: Record<string, string> = {};
+    for (const key of plugin.manifest.requiresCredential ?? []) {
+      credentials[key] = await resolveCredentialOrThrow(name, key);
+    }
+
+    const config = validatePluginConfig(
+      name,
+      plugin.manifest.config,
+      getPluginConfigRaw(ctx.config, name),
+    );
+
+    const initContext = {
+      config,
+      credentials,
+      logger: log.child({ plugin: name }),
+      pluginStorageDir: ensurePluginStorageDir(name),
+      assistantVersion: ctx.assistantVersion,
+    };
+
+    if (plugin.tools && plugin.tools.length > 0) {
+      try {
+        const accepted = registerPluginTools(name, plugin.tools);
+        log.info(
+          { plugin: name, count: accepted.length },
+          "plugin tools registered",
+        );
+      } catch (err) {
+        throw new PluginExecutionError(
+          `plugin ${name} tool registration failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+          name,
+          { cause: err },
+        );
+      }
+    }
+
+    if (plugin.routes && plugin.routes.length > 0) {
+      for (const route of plugin.routes) {
+        routeHandles.push(registerSkillRoute(route));
+      }
+      log.info(
+        { plugin: name, count: plugin.routes.length },
+        "plugin routes registered",
+      );
+    }
+
+    if (plugin.skills && plugin.skills.length > 0) {
+      try {
+        registerPluginSkills(
+          name,
+          plugin.skills as readonly PluginSkillRegistration[],
+        );
+      } catch (err) {
+        throw new PluginExecutionError(
+          `plugin ${name} skill registration failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+          name,
+          { cause: err },
+        );
+      }
+    }
+
+    if (plugin.hooks?.[HOOKS.INIT]) {
+      try {
+        await plugin.hooks[HOOKS.INIT](initContext);
+      } catch (err) {
+        throw new PluginExecutionError(
+          `plugin ${name} init() failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+          name,
+          { cause: err },
+        );
+      }
+    }
+    initCompleted = true;
+
+    log.info({ plugin: name }, "plugin initialized");
+    return { plugin, routeHandles };
+  } catch (err) {
+    if (initCompleted) {
+      await teardownPlugin({ plugin, routeHandles }, "bootstrap-failed", {
+        assistantVersion: ctx.assistantVersion,
+      });
+    } else {
+      for (const handle of routeHandles) {
+        unregisterSkillRoute(handle);
+      }
+      unregisterPluginTools(name);
+      if (plugin.skills && plugin.skills.length > 0) {
+        unregisterPluginSkills(name);
+      }
+    }
+    throw err;
+  }
+}
+
 /**
  * Tear down a single fully-initialized plugin: unregister routes, unregister
  * tools, invoke `onShutdown()` if present, then unregister skills. Every step
@@ -473,6 +444,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 +476,17 @@ async function teardownPlugin(
     );
   }
 
-  if (plugin.onShutdown) {
+  if (plugin.hooks?.[HOOKS.SHUTDOWN]) {
     try {
-      await plugin.onShutdown();
+      await plugin.hooks[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)",
       );
     }
   }
@@ -530,3 +502,77 @@ async function teardownPlugin(
     }
   }
 }
+
+/** Rebuild a changed external plugin and swap it into the live registry. */
+export async function reregisterExternalPlugin(
+  pluginName: string,
+): Promise<void> {
+  const pluginDir = join(getWorkspaceDir(), "plugins", pluginName);
+  const plugin = await buildExternalPlugin(pluginDir);
+  if (plugin === undefined) return;
+
+  if (plugin.manifest.name !== pluginName) {
+    log.warn(
+      { plugin: pluginName, manifestName: plugin.manifest.name, pluginDir },
+      `external plugin reload skipped: directory name "${pluginName}" does not match manifest.name "${plugin.manifest.name}"`,
+    );
+    return;
+  }
+
+  const ctx: DaemonContext = {
+    config: getConfig(),
+    assistantVersion: APP_VERSION,
+  };
+  const disabledFlag = getDisabledPluginFlag(plugin, ctx.config);
+  if (disabledFlag !== undefined) {
+    log.info(
+      { plugin: pluginName, flag: disabledFlag },
+      `external plugin reload skipped: feature flag ${disabledFlag} is disabled`,
+    );
+    return;
+  }
+
+  const existing = getRegisteredPlugin(pluginName);
+  if (existing === undefined) {
+    try {
+      await initializePlugin(plugin, ctx);
+      setRegisteredPlugin(plugin);
+      log.info({ plugin: pluginName }, "external plugin registered post-boot");
+    } catch (err) {
+      log.error(
+        { err, plugin: pluginName },
+        "external plugin post-boot registration failed",
+      );
+    }
+    return;
+  }
+
+  try {
+    unregisterPluginTools(pluginName);
+  } catch (err) {
+    log.warn(
+      { err, plugin: pluginName },
+      "external plugin reload: tool unregister failed (continuing)",
+    );
+  }
+
+  setRegisteredPlugin(plugin);
+
+  if (plugin.tools && plugin.tools.length > 0) {
+    try {
+      const accepted = registerPluginTools(pluginName, plugin.tools);
+      log.info(
+        { plugin: pluginName, count: accepted.length },
+        "external plugin reloaded",
+      );
+    } catch (err) {
+      log.error(
+        { err, plugin: pluginName },
+        "external plugin reload: tool registration failed",
+      );
+    }
+    return;
+  }
+
+  log.info({ plugin: pluginName }, "external plugin reloaded");
+}

package/src/daemon/first-greeting.ts

@@ -11,6 +11,7 @@ export interface OnboardingGreetingContext {
   tone: string;
   userName?: string;
   assistantName?: string;
+  googleConnected?: boolean;
 }
 
 export const CANNED_FIRST_GREETING = [
@@ -76,6 +77,16 @@ const TONE_INVITE: Record<Tone, string> = {
     "We can start with whatever's in front of you, or just talk for a bit first. Either way.",
 };
 
+const TONE_GOOGLE_SCAN: Record<Tone, string> = {
+  grounded:
+    "I can scan your email, calendar, and drive in the background while we talk — just say the word.",
+  warm: "Also — I can scan your email, calendar, and drive in the background while we chat, if you'd like. Just let me know.",
+  energetic:
+    "Oh, and I can scan your email, calendar, and drive in the background right now — want me to?",
+  poetic:
+    "I can also look through your email, calendar, and drive quietly in the background — say the word.",
+};
+
 function buildInvite(tone: Tone = "grounded"): string {
   return TONE_INVITE[tone];
 }
@@ -96,11 +107,20 @@ function buildPersonalizedGreeting(ctx: OnboardingGreetingContext): string {
   const assistant = ctx.assistantName?.trim();
   const tone = resolveTone(ctx.tone);
 
-  if (!name && !assistant && !VALID_TONES.has(ctx.tone)) {
+  if (
+    !name &&
+    !assistant &&
+    !VALID_TONES.has(ctx.tone) &&
+    !ctx.googleConnected
+  ) {
     return CANNED_FIRST_GREETING;
   }
 
   const intro = buildIntroLine(name, assistant, tone);
   const invite = buildInvite(tone);
-  return [intro, "", invite].join("\n");
+  const parts = [intro, "", invite];
+  if (ctx.googleConnected) {
+    parts.push("", TONE_GOOGLE_SCAN[tone]);
+  }
+  return parts.join("\n");
 }

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