@vellumai/assistant 0.8.8-dev.202606091702.2771079 → 0.8.9-dev.202606091853.fbaa2ae

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.8.8
+  version: 0.8.9
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.8-dev.202606091702.2771079",
+  "version": "0.8.9-dev.202606091853.fbaa2ae",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/notification-decision-strategy.test.ts

@@ -9,17 +9,17 @@
 
 import { describe, expect, test } from "bun:test";
 
-import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
 import {
   buildAccessRequestContractText,
   buildAccessRequestIdentityLine,
-  composeFallbackCopy,
   hasAccessRequestInstructions,
   hasInviteFlowDirective,
   normalizeForDirectiveMatching,
   sanitizeIdentityField,
   sanitizeMessagePreview,
-} from "../notifications/copy-composer.js";
+} from "../notifications/access-request-copy.js";
+import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
+import { composeFallbackCopy } from "../notifications/copy-composer.js";
 import {
   enforceGuardianCallConversationAffinity,
   validateConversationActions,

package/src/__tests__/plugin-bootstrap.test.ts

@@ -42,11 +42,7 @@ import {
   registerPlugin,
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
-import {
-  type Plugin,
-  PluginExecutionError,
-  type PluginInitContext,
-} from "../plugins/types.js";
+import { type Plugin, type PluginInitContext } from "../plugins/types.js";
 import { APP_VERSION } from "../version.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
@@ -174,9 +170,9 @@ describe("plugin bootstrap", () => {
     expect(received?.credentials).toEqual({ "some-key": "super-secret-value" });
   });
 
-  test("credential resolution: missing credential fails bootstrap with the plugin named", async () => {
+  test("credential resolution: a plugin whose required credential is missing is skipped, not fatal", async () => {
+    // GIVEN a plugin that requires a credential the store cannot resolve
     getSecureKeyAsyncMock.mockImplementation(async () => undefined);
-
     registerPlugin(
       buildPlugin(
         "missing-cred",
@@ -185,16 +181,14 @@ describe("plugin bootstrap", () => {
       ),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("missing-cred");
-    expect(msg).toContain("absent-key");
+    // WHEN bootstrap runs
+    // THEN it completes without throwing — the unresolvable credential is
+    // contained to that plugin (same per-plugin isolation as an init throw)
+    await bootstrapPlugins();
+
+    // AND the plugin is dropped from the registry
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("missing-cred");
   });
 
   test("version mismatch: external plugin loader rejects when peerDependency unsatisfied", async () => {
@@ -208,7 +202,8 @@ describe("plugin bootstrap", () => {
     expect(() => registerPlugin(plugin)).not.toThrow();
   });
 
-  test("plugin init throw: bootstrap throws a PluginExecutionError naming the plugin", async () => {
+  test("plugin init throw: bootstrap contains the failure and does not throw", async () => {
+    // GIVEN a plugin whose init throws
     registerPlugin(
       buildPlugin("broken", {
         async init() {
@@ -217,65 +212,91 @@ describe("plugin bootstrap", () => {
       }),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("broken");
-    expect(msg).toContain("kaboom");
+    // WHEN bootstrap runs
+    // THEN it completes without throwing — a single plugin's init failure is
+    // contained to that plugin rather than aborting the whole plugin layer
+    await bootstrapPlugins();
+
+    // AND the failing plugin is dropped from the registry so its hooks never
+    // participate in the turn lifecycle
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("broken");
   });
 
-  test("partial-init failure: earlier plugins' onShutdown runs in reverse before the error propagates", async () => {
-    // If plugin N throws during init, every plugin 1..N-1 that already made
-    // it through its full init+contribution phase must have onShutdown()
-    // invoked in reverse registration order before bootstrap re-throws.
-    // Without this, earlier plugins leak live tools/routes/skills because
-    // the shutdown hook is only registered once the entire loop completes.
-    const callOrder: string[] = [];
+  test("mid-list init failure: surrounding plugins still initialize and survive", async () => {
+    // GIVEN two healthy plugins surrounding one whose init throws, registered
+    // in order
+    const initialized: string[] = [];
+    const shutDownDuringBootstrap: string[] = [];
     registerPlugin(
-      buildPlugin("survivor-a", {
-        async init() {},
+      buildPlugin("before", {
+        async init() {
+          initialized.push("before");
+        },
         async onShutdown() {
-          callOrder.push("survivor-a");
+          shutDownDuringBootstrap.push("before");
         },
       }),
     );
     registerPlugin(
-      buildPlugin("survivor-b", {
-        async init() {},
-        async onShutdown() {
-          callOrder.push("survivor-b");
+      buildPlugin("failing", {
+        async init() {
+          throw new Error("mid-bootstrap failure");
         },
       }),
     );
     registerPlugin(
-      buildPlugin("failing", {
+      buildPlugin("after", {
         async init() {
-          throw new Error("mid-bootstrap failure");
+          initialized.push("after");
         },
         async onShutdown() {
-          // Never called — this plugin never completes init, so it was never
-          // added to the active list that teardown walks.
-          callOrder.push("failing");
+          shutDownDuringBootstrap.push("after");
         },
       }),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-
-    // Reverse order: survivor-b registered after survivor-a, so it tears
-    // down first; "failing" never entered the active list.
-    expect(callOrder).toEqual(["survivor-b", "survivor-a"]);
+    // WHEN bootstrap runs
+    await bootstrapPlugins();
+
+    // THEN both healthy plugins initialized — the one registered after the
+    // failure is not skipped
+    expect(initialized).toEqual(["before", "after"]);
+    // AND neither healthy plugin was torn down by the failure (their
+    // onShutdown only runs at real shutdown, not during bootstrap)
+    expect(shutDownDuringBootstrap).toEqual([]);
+    // AND the failing plugin is dropped while both survivors remain registered
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).toContain("before");
+    expect(names).toContain("after");
+    expect(names).not.toContain("failing");
+  });
+
+  test("user-plugin init failure leaves the first-party defaults registered", async () => {
+    // GIVEN the first-party defaults are registered ahead of user plugins, as
+    // at daemon startup
+    registerDefaultPlugins();
+    // AND a user plugin registered after them whose init throws
+    registerPlugin(
+      buildPlugin("breaking-user-plugin", {
+        async init() {
+          throw new Error("user plugin boom");
+        },
+      }),
+    );
+
+    // WHEN bootstrap runs
+    await bootstrapPlugins();
+
+    // THEN the failing user plugin is dropped from the registry
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("breaking-user-plugin");
+    // AND every first-party default survived, so core turn behavior (memory
+    // retrieval, history repair, title generation) keeps running in degraded
+    // mode instead of being torn down with the failing plugin
+    expect(names).toContain("default-memory-retrieval");
+    expect(names).toContain("default-history-repair");
+    expect(names).toContain("default-title-generate");
   });
 
   test("shutdown order: onShutdown fires in reverse registration order", async () => {

package/src/__tests__/plugin-skill-contribution.test.ts

@@ -202,7 +202,8 @@ describe("plugin skill contributions", () => {
     expect(getPluginContributedSkillSummaries()).toEqual([]);
   });
 
-  test("duplicate skill id across plugins fails bootstrap with the plugin named", async () => {
+  test("duplicate skill id across plugins drops the colliding plugin, keeping the first", async () => {
+    // GIVEN two plugins that both declare the same skill id
     const shared: PluginSkillRegistration = {
       id: "contested-id",
       name: "contested",
@@ -215,22 +216,22 @@ describe("plugin skill contributions", () => {
       description: "Second",
       body: "from second plugin",
     };
-
+    // AND the first registered plugin claims the id; the second collides on it
     registerPlugin(buildSkillPlugin("first-plugin", [shared]));
     registerPlugin(buildSkillPlugin("second-plugin", [duplicate]));
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    // The error must identify which plugin tripped the collision so
-    // operators can deploy a fix.
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("second-plugin");
-    expect(msg).toContain("contested-id");
+    // WHEN bootstrap runs
+    // THEN it does not throw — the collision is contained to the colliding
+    // plugin rather than aborting the whole plugin layer
+    await bootstrapPlugins();
+
+    // AND the first plugin keeps the contested skill, while the second
+    // plugin's colliding contribution is rolled back and dropped
+    expect(
+      getPluginContributedSkillDefinition("contested-id")?.description,
+    ).toBe("First");
+    expect(getPluginSkillRefCount("first-plugin")).toBe(1);
+    expect(getPluginSkillRefCount("second-plugin")).toBe(0);
   });
 
   test("intra-batch duplicate skill id in one plugin is rejected at registration", () => {

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -218,9 +218,7 @@ describe("plugin tool contributions", () => {
   });
 
   test("tools are only registered after init() succeeds", async () => {
-    // A plugin whose init throws must not contribute tools — the bootstrap
-    // aborts with a PluginExecutionError, and nothing from this plugin
-    // should leak into the tool registry.
+    // GIVEN a plugin that declares a tool but throws during init()
     const plugin = buildPlugin("delta-broken", {
       async init() {
         throw new Error("boom");
@@ -229,7 +227,12 @@ describe("plugin tool contributions", () => {
     });
     registerPlugin(plugin);
 
-    await expect(bootstrapPlugins()).rejects.toThrow(/delta-broken/);
+    // WHEN bootstrap runs
+    // THEN it does not throw — the init failure is contained to this plugin
+    await bootstrapPlugins();
+
+    // AND the failing plugin's tool is rolled back, never leaking into the
+    // registry
     expect(getTool("delta-tool")).toBeUndefined();
   });
 });

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

@@ -37,14 +37,15 @@
  *    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. 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.
+ * 8. Awaits `plugin.init(ctx)` sequentially. An init failure is contained to
+ *    the offending plugin: its already-registered tools, routes, and skills
+ *    are rolled back, it is dropped from the registry, the failure is logged,
+ *    and bootstrap continues with the remaining plugins. A single plugin's
+ *    failure never deregisters plugins that already initialized — in
+ *    particular the first-party defaults, which carry core turn behavior
+ *    (memory retrieval, history repair, title generation) — so the daemon
+ *    comes up with the failing plugin absent rather than blacking out the
+ *    whole plugin layer.
  *
  * A single shutdown hook is registered via
  * {@link registerShutdownHook} that walks the plugin list in **reverse
@@ -218,9 +219,10 @@ export async function initializePlugins(): Promise<void> {
  * Run every registered plugin's `init()` hook sequentially and install a
  * reverse-order shutdown hook. See the module docstring for full semantics.
  *
- * Returns once every plugin has finished initialising successfully. Throws a
- * {@link PluginExecutionError} on the first failure — the error message names
- * the offending plugin so operators see which `init()` bailed.
+ * Returns once every plugin has been processed. A plugin whose `init()` throws
+ * is rolled back, dropped from the registry, and logged; bootstrap continues
+ * with the rest, so one failing plugin never blocks the others — or the
+ * first-party defaults — from coming up.
  *
  * Must be called after any custom/third-party plugin registrations have run
  * and before the first conversation is served. First-party defaults are
@@ -259,35 +261,14 @@ export async function bootstrapPlugins(): Promise<void> {
   // onShutdown" invariant.
   const activePlugins: ActivePlugin[] = [];
 
-  // Tear down a plugin's contributions AND remove it from the registry. The
-  // two steps always move together on the bootstrap failure path: the former
-  // clears tools/routes/skills (so they stop appearing to the model/HTTP
-  // server), the latter drops the plugin's entry from the Map (so the registry
-  // doesn't expose an uninitialized plugin's hooks).
   // 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}.
+  // once and reuse across the per-plugin teardown and the normal shutdown
+  // hook below. Only `assistantVersion` is exposed today; future additions
+  // live on {@link PluginShutdownContext}.
   const shutdownContext: PluginShutdownContext = {
     assistantVersion: APP_VERSION,
   };
 
-  async function rollbackPlugin(active: ActivePlugin): Promise<void> {
-    await teardownPlugin(active, "bootstrap-failed", shutdownContext);
-    unregisterPlugin(active.plugin.manifest.name);
-  }
-
-  // If one plugin's init or contribution phase throws, tear down any plugins
-  // that already fully initialized (in reverse registration order) before
-  // re-throwing. Without this, a mid-loop failure would leave earlier plugins
-  // with live tools/routes/skills and no `onShutdown()` call — the shutdown
-  // hook is only registered once the loop completes successfully.
-  async function teardownPartialInit(): Promise<void> {
-    for (let i = activePlugins.length - 1; i >= 0; i--) {
-      await rollbackPlugin(activePlugins[i]!);
-    }
-  }
-
   for (const plugin of plugins) {
     const name = plugin.manifest.name;
     const disabledFlag = getDisabledPluginFlag(plugin, assistantConfig);
@@ -303,9 +284,18 @@ export async function bootstrapPlugins(): Promise<void> {
     try {
       activePlugins.push(await initializePlugin(plugin, assistantConfig));
     } catch (err) {
+      // Contain the failure to this plugin. `initializePlugin` already rolled
+      // back its own partial tool/route/skill contributions, so we just drop
+      // it from the registry and move on. A single plugin's init failure must
+      // never deregister the plugins that already came up — above all the
+      // first-party defaults, which carry core turn behavior. The daemon stays
+      // reachable with the failing plugin absent rather than losing the whole
+      // plugin layer.
       unregisterPlugin(name);
-      await teardownPartialInit();
-      throw err;
+      log.warn(
+        { err, plugin: name },
+        `plugin ${name} failed to initialize — skipping (continuing with remaining plugins)`,
+      );
     }
   }
 

package/src/notifications/__tests__/copy-composer.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Tests for the notification copy-composer — specifically the fallback
+ * path that composeFallbackCopy uses when the LLM is unavailable, and
+ * the shared deriveTitle utility.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { composeFallbackCopy, deriveTitle } from "../copy-composer.js";
+import type { NotificationSignal } from "../signal.js";
+import type { NotificationChannel } from "../types.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+function makeSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: "sig-copy-test-1",
+    createdAt: Date.now(),
+    sourceChannel: "scheduler",
+    sourceContextId: "ctx-1",
+    sourceEventName: "user.send_notification",
+    contextPayload: {},
+    attentionHints: {
+      requiresAction: false,
+      urgency: "low",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+const CHANNELS: NotificationChannel[] = ["vellum" as NotificationChannel];
+
+// ── composeFallbackCopy with requestedMessage ─────────────────────────
+
+describe("composeFallbackCopy honors requestedMessage / requestedTitle", () => {
+  test("uses requestedMessage as body and requestedTitle as title", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "Take out the trash",
+        requestedTitle: "Household Reminder",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("Take out the trash");
+    expect(copy.vellum?.title).toBe("Household Reminder");
+    expect(copy.vellum?.conversationSeedMessage).toBe("Take out the trash");
+  });
+
+  test("derives title from body when requestedTitle is absent", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "First sentence. Second sentence follows.",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("First sentence. Second sentence follows.");
+    expect(copy.vellum?.title).toBe("First sentence.");
+  });
+
+  test("derives title from body when requestedTitle is empty string", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "Some message body here",
+        requestedTitle: "",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("Some message body here");
+    expect(copy.vellum?.title).toBe("Some message body here");
+  });
+
+  test("derives title from body when requestedTitle is whitespace", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "Whitespace title test",
+        requestedTitle: "   ",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("Whitespace title test");
+    expect(copy.vellum?.title).toBe("Whitespace title test");
+  });
+
+  test("trims whitespace from requestedMessage", () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "  padded message  ",
+        requestedTitle: "  padded title  ",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("padded message");
+    expect(copy.vellum?.title).toBe("padded title");
+  });
+
+  test("populates copy for all requested channels", () => {
+    const channels = [
+      "vellum" as NotificationChannel,
+      "telegram" as NotificationChannel,
+    ];
+    const signal = makeSignal({
+      contextPayload: {
+        requestedMessage: "Multi-channel test",
+        requestedTitle: "Multi Title",
+      },
+    });
+    const copy = composeFallbackCopy(signal, channels);
+
+    expect(copy.vellum?.body).toBe("Multi-channel test");
+    expect(copy.vellum?.title).toBe("Multi Title");
+    expect(copy.telegram?.body).toBe("Multi-channel test");
+    expect(copy.telegram?.title).toBe("Multi Title");
+  });
+
+  test("falls through to template when requestedMessage is absent", () => {
+    const signal = makeSignal({
+      sourceEventName: "schedule.notify",
+      contextPayload: {
+        message: "Standup time",
+        label: "Daily Standup",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.title).toBe("Daily Standup");
+    expect(copy.vellum?.body).toBe("Standup time");
+  });
+
+  test("falls through to template when requestedMessage is empty string", () => {
+    const signal = makeSignal({
+      sourceEventName: "schedule.notify",
+      contextPayload: {
+        requestedMessage: "",
+        message: "Standup time",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.title).toBe("Reminder");
+    expect(copy.vellum?.body).toBe("Standup time");
+  });
+
+  test("falls through to template when requestedMessage is whitespace", () => {
+    const signal = makeSignal({
+      sourceEventName: "schedule.notify",
+      contextPayload: {
+        requestedMessage: "   ",
+        message: "Standup time",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.title).toBe("Reminder");
+    expect(copy.vellum?.body).toBe("Standup time");
+  });
+
+  test("falls through to generic copy when no requestedMessage and no template match", () => {
+    const signal = makeSignal({
+      sourceEventName: "unknown.event",
+      contextPayload: {},
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.title).toBe("Notification");
+    expect(copy.vellum?.body).toBe("");
+  });
+
+  test("requestedMessage takes priority over event-name template", () => {
+    const signal = makeSignal({
+      sourceEventName: "schedule.notify",
+      contextPayload: {
+        requestedMessage: "User-supplied content",
+        requestedTitle: "User Title",
+        message: "Template message field",
+        label: "Template label field",
+      },
+    });
+    const copy = composeFallbackCopy(signal, CHANNELS);
+
+    expect(copy.vellum?.body).toBe("User-supplied content");
+    expect(copy.vellum?.title).toBe("User Title");
+  });
+
+  test("works with non-assistant_tool source channels", () => {
+    for (const sourceChannel of ["scheduler", "watcher", "slack"] as const) {
+      const signal = makeSignal({
+        sourceChannel,
+        contextPayload: {
+          requestedMessage: `Message from ${sourceChannel}`,
+        },
+      });
+      const copy = composeFallbackCopy(signal, CHANNELS);
+
+      expect(copy.vellum?.body).toBe(`Message from ${sourceChannel}`);
+    }
+  });
+});
+
+// ── deriveTitle ───────────────────────────────────────────────────────
+
+describe("deriveTitle", () => {
+  test("extracts first sentence when period is present", () => {
+    expect(deriveTitle("First sentence. Second sentence.")).toBe(
+      "First sentence.",
+    );
+  });
+
+  test("extracts first sentence on exclamation mark", () => {
+    expect(deriveTitle("Alert! More details follow.")).toBe("Alert!");
+  });
+
+  test("extracts first sentence on question mark", () => {
+    expect(deriveTitle("Ready? Let me know.")).toBe("Ready?");
+  });
+
+  test("uses full body when no sentence terminator", () => {
+    expect(deriveTitle("No terminator here")).toBe("No terminator here");
+  });
+
+  test("truncates to 60 characters with ellipsis", () => {
+    const long = "A".repeat(80);
+    const result = deriveTitle(long);
+    expect(result.length).toBeLessThanOrEqual(61); // 60 + ellipsis char
+    expect(result.endsWith("\u2026")).toBe(true);
+  });
+
+  test("does not truncate at exactly 60 characters", () => {
+    const exact = "A".repeat(60);
+    expect(deriveTitle(exact)).toBe(exact);
+  });
+
+  test("trims whitespace", () => {
+    expect(deriveTitle("  trimmed  ")).toBe("trimmed");
+  });
+});