@vellumai/assistant 0.8.1 → 0.8.3

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,24 @@ 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";
@@ -84,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");
@@ -170,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.
@@ -245,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.hooks?.init) {
-        try {
-          await plugin.hooks.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;
     }
@@ -470,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
@@ -514,9 +476,9 @@ async function teardownPlugin(
     );
   }
 
-  if (plugin.hooks?.shutdown) {
+  if (plugin.hooks?.[HOOKS.SHUTDOWN]) {
     try {
-      await plugin.hooks.shutdown(shutdownContext);
+      await plugin.hooks[HOOKS.SHUTDOWN](shutdownContext);
     } catch (err) {
       // Swallow — we want every plugin's shutdown to get a chance to run
       // even when an earlier one throws. The outer runShutdownHooks already
@@ -540,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

@@ -9,12 +9,7 @@ import {
   GUARDIAN_ACTION_COPY_TIMEOUT_MS,
   includesRequiredKeywords,
 } from "../runtime/guardian-action-message-composer.js";
-import type {
-  GuardianActionCopyGenerator,
-  GuardianFollowUpConversationGenerator,
-  GuardianFollowUpDisposition,
-  GuardianFollowUpTurnResult,
-} from "../runtime/http-types.js";
+import type { GuardianActionCopyGenerator } from "../runtime/http-types.js";
 
 /**
  * Create the daemon-owned guardian action copy generator that resolves
@@ -74,122 +69,3 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
     return cleaned;
   };
 }
-
-// ---------------------------------------------------------------------------
-// Guardian follow-up conversation generator
-// ---------------------------------------------------------------------------
-
-const FOLLOWUP_CONVERSATION_TIMEOUT_MS = 8_000;
-const FOLLOWUP_CONVERSATION_MAX_TOKENS = 300;
-
-const FOLLOWUP_CONVERSATION_SYSTEM_PROMPT =
-  "You are an assistant helping route a guardian's reply to a post-timeout follow-up message. " +
-  "A voice caller asked a question, but the call timed out before the guardian could answer. " +
-  "The guardian has now replied late, and was asked whether they want to call the caller back " +
-  "or skip it. " +
-  "Analyze the guardian's latest reply to determine their intent. " +
-  "When uncertain, default to keep_pending and ask a clarifying question. " +
-  "Always provide a natural, helpful reply along with your decision.";
-
-const FOLLOWUP_CONVERSATION_TOOL_NAME = "followup_decision";
-
-const FOLLOWUP_CONVERSATION_TOOL_SCHEMA = {
-  name: FOLLOWUP_CONVERSATION_TOOL_NAME,
-  description:
-    "Record the guardian's follow-up decision and a natural reply. " +
-    "Call this tool with the determined disposition and a reply to the guardian.",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      disposition: {
-        type: "string",
-        enum: ["call_back", "decline", "keep_pending"],
-        description:
-          "The guardian's intent: call_back to call the original caller, " +
-          "decline to skip the follow-up, " +
-          "keep_pending if the intent is unclear (ask for clarification).",
-      },
-      replyText: {
-        type: "string",
-        description: "A natural language reply to send back to the guardian.",
-      },
-    },
-    required: ["disposition", "replyText"],
-  },
-};
-
-const VALID_FOLLOWUP_DISPOSITIONS: ReadonlySet<string> = new Set([
-  "call_back",
-  "decline",
-  "keep_pending",
-]);
-
-/**
- * Create the daemon-owned guardian follow-up conversation generator.
- * Uses tool/function calling to produce structured dispositions alongside
- * natural reply text. Follows the same pattern as
- * createApprovalConversationGenerator().
- */
-export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpConversationGenerator {
-  return async (context) => {
-    const baseProvider = await getConfiguredProvider("guardianQuestionCopy");
-    if (!baseProvider) {
-      throw new Error("No configured provider available for follow-up conversation");
-    }
-    const provider = wrapWithCallSiteRouting(baseProvider, loadConfig());
-
-    const userPrompt = [
-      `Original question from the voice call: "${context.questionText}"`,
-      `Guardian's late answer: "${context.lateAnswerText}"`,
-      `\nGuardian's latest reply: ${context.guardianReply}`,
-    ].join("\n");
-
-    const response = await provider.sendMessage(
-      [{ role: "user", content: [{ type: "text", text: userPrompt }] }],
-      [FOLLOWUP_CONVERSATION_TOOL_SCHEMA],
-      FOLLOWUP_CONVERSATION_SYSTEM_PROMPT,
-      {
-        config: {
-          max_tokens: FOLLOWUP_CONVERSATION_MAX_TOKENS,
-          callSite: "guardianQuestionCopy",
-        },
-        signal: AbortSignal.timeout(FOLLOWUP_CONVERSATION_TIMEOUT_MS),
-      },
-    );
-
-    // Extract the tool_use block from the response
-    const toolUseBlock = response.content.find(
-      (block) =>
-        block.type === "tool_use" &&
-        block.name === FOLLOWUP_CONVERSATION_TOOL_NAME,
-    );
-
-    if (!toolUseBlock || toolUseBlock.type !== "tool_use") {
-      throw new Error(
-        "Provider did not return a tool_use block for follow-up decision",
-      );
-    }
-
-    const input = toolUseBlock.input as Record<string, unknown>;
-
-    // Strict validation of the structured output
-    const disposition = input.disposition;
-    if (
-      typeof disposition !== "string" ||
-      !VALID_FOLLOWUP_DISPOSITIONS.has(disposition)
-    ) {
-      throw new Error(`Invalid disposition: ${String(disposition)}`);
-    }
-
-    const replyText = input.replyText;
-    if (typeof replyText !== "string" || replyText.trim().length === 0) {
-      throw new Error("Missing or empty replyText in tool_use response");
-    }
-
-    const result: GuardianFollowUpTurnResult = {
-      disposition: disposition as GuardianFollowUpDisposition,
-      replyText: replyText.trim(),
-    };
-    return result;
-  };
-}