@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

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

@@ -16,9 +16,8 @@
  *    the plugin is skipped wholesale — no `init()`, no tool/route/skill
  *    contributions, no entry in the shutdown hook, and the plugin is also
  *    dropped from the registry via {@link unregisterPlugin} so its middleware
- *    and injectors stop participating in pipeline runs and system-prompt
- *    assembly. This is the primary mechanism for shipping experimental
- *    plugins behind a feature flag.
+ *    stops participating in pipeline runs. This is the primary mechanism for
+ *    shipping experimental plugins behind a feature flag.
  * 4. Resolves the plugin's `manifest.requiresCredential` entries via the
  *    credential store helper ({@link getSecureKeyAsync}). In Docker mode
  *    that helper goes through the CES HTTP API transparently; in local mode
@@ -65,6 +64,7 @@ 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 { installPluginRuntime } from "../plugins/external-api.js";
 import { buildExternalPlugin } from "../plugins/external-plugin-loader.js";
 import {
   registerPluginSkills,
@@ -82,6 +82,7 @@ import {
   type PluginShutdownContext,
   type PluginSkillRegistration,
 } from "../plugins/types.js";
+import { loadUserPlugins } from "../plugins/user-loader.js";
 import {
   registerSkillRoute,
   type SkillRouteHandle,
@@ -99,16 +100,6 @@ import { registerShutdownHook } from "./shutdown-registry.js";
 
 const log = getLogger("plugins-bootstrap");
 
-/**
- * Minimal context required to bootstrap the plugin layer. Kept intentionally
- * small so the call site in `lifecycle.ts` can construct it from whatever
- * state is already available at that point in startup.
- */
-export interface DaemonContext {
-  config: AssistantConfig;
-  assistantVersion: string;
-}
-
 /**
  * Resolve one credential value. Returns the raw secret string or throws a
  * {@link PluginExecutionError} tagged with the plugin name so the caller can
@@ -191,6 +182,37 @@ function getDisabledPluginFlag(
   return undefined;
 }
 
+/**
+ * Bring the plugin layer up during daemon startup. Runs the full sequence in
+ * the one order the rest of the system depends on:
+ *
+ * 1. Install the `globalThis.__vellumPluginRuntime` bridge so plugins can touch
+ *    it from their module body (see `plugins/external-api.ts` — compiled-binary
+ *    module identity).
+ * 2. Register the first-party defaults so their middleware composes innermost,
+ *    ahead of any user plugins.
+ * 3. Load user plugins from `<workspaceDir>/plugins/*`. A failing user plugin is
+ *    logged and skipped; `loadUserPlugins()` closes the registration window
+ *    when it returns, so the defaults must already be registered by then.
+ * 4. Run every registered plugin's `init()` via {@link bootstrapPlugins}.
+ *
+ * Plugin bootstrap is wrapped so a failing plugin cannot block daemon startup —
+ * the daemon comes up with degraded plugin functionality instead.
+ */
+export async function initializePlugins(): Promise<void> {
+  installPluginRuntime();
+  registerDefaultPlugins();
+  await loadUserPlugins();
+  try {
+    await bootstrapPlugins();
+  } catch (err) {
+    log.warn(
+      { err },
+      "Plugin bootstrap failed — continuing startup with degraded plugin functionality",
+    );
+  }
+}
+
 /**
  * Run every registered plugin's `init()` hook sequentially and install a
  * reverse-order shutdown hook. See the module docstring for full semantics.
@@ -203,9 +225,9 @@ function getDisabledPluginFlag(
  * and before the first conversation is served. First-party defaults are
  * registered inline via {@link registerDefaultPlugins}.
  */
-export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
+export async function bootstrapPlugins(): Promise<void> {
   // Register first-party default plugins. Each default wraps one of the
-  // assistant's canonical pipelines (`toolExecute`, `llmCall`, ...) with a
+  // assistant's canonical pipelines (`compaction`, `persistence`, ...) with a
   // passthrough so the pipeline shape is explicit at boot even when no
   // third-party plugins are loaded. Registration is idempotent via the
   // already-registered guard so repeated calls (e.g. during integration
@@ -214,8 +236,8 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
   const plugins = getRegisteredPlugins();
   if (plugins.length === 0) {
-    // No-op fast path. The default injectors normally populate the registry,
-    // so this branch is primarily for tests that call
+    // No-op fast path. The default plugins normally populate the registry, so
+    // this branch is primarily for tests that call
     // `resetPluginRegistryForTests()` and stub the default registration.
     log.debug("bootstrapPlugins: registry empty — skipping");
     return;
@@ -223,6 +245,8 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
   log.info({ count: plugins.length }, "bootstrapPlugins: initializing plugins");
 
+  const assistantConfig = getConfig();
+
   // Plugins that passed `requiresFlag` gating and therefore need the full
   // init → contribute → shutdown lifecycle. Plugins skipped by the flag gate
   // are omitted from this list so the shutdown hook below never tears down
@@ -238,14 +262,14 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
   // 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
-  // `getMiddlewaresFor` / `getInjectors` don't re-enter an uninitialized
-  // plugin on the next pipeline invocation).
+  // `getMiddlewaresFor` doesn'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,
+    assistantVersion: APP_VERSION,
   };
 
   async function rollbackPlugin(active: ActivePlugin): Promise<void> {
@@ -266,7 +290,7 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
   for (const plugin of plugins) {
     const name = plugin.manifest.name;
-    const disabledFlag = getDisabledPluginFlag(plugin, ctx.config);
+    const disabledFlag = getDisabledPluginFlag(plugin, assistantConfig);
     if (disabledFlag !== undefined) {
       log.info(
         { plugin: name, flag: disabledFlag },
@@ -277,7 +301,7 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
     }
 
     try {
-      activePlugins.push(await initializePlugin(plugin, ctx));
+      activePlugins.push(await initializePlugin(plugin, assistantConfig));
     } catch (err) {
       unregisterPlugin(name);
       await teardownPartialInit();
@@ -326,7 +350,7 @@ interface ActivePlugin {
 
 async function initializePlugin(
   plugin: Plugin,
-  ctx: DaemonContext,
+  assistantConfig: AssistantConfig,
 ): Promise<ActivePlugin> {
   const name = plugin.manifest.name;
   const routeHandles: SkillRouteHandle[] = [];
@@ -341,7 +365,7 @@ async function initializePlugin(
     const config = validatePluginConfig(
       name,
       plugin.manifest.config,
-      getPluginConfigRaw(ctx.config, name),
+      getPluginConfigRaw(assistantConfig, name),
     );
 
     const initContext = {
@@ -349,7 +373,7 @@ async function initializePlugin(
       credentials,
       logger: log.child({ plugin: name }),
       pluginStorageDir: ensurePluginStorageDir(name),
-      assistantVersion: ctx.assistantVersion,
+      assistantVersion: APP_VERSION,
     };
 
     if (plugin.tools && plugin.tools.length > 0) {
@@ -417,7 +441,7 @@ async function initializePlugin(
   } catch (err) {
     if (initCompleted) {
       await teardownPlugin({ plugin, routeHandles }, "bootstrap-failed", {
-        assistantVersion: ctx.assistantVersion,
+        assistantVersion: APP_VERSION,
       });
     } else {
       for (const handle of routeHandles) {
@@ -519,11 +543,8 @@ export async function reregisterExternalPlugin(
     return;
   }
 
-  const ctx: DaemonContext = {
-    config: getConfig(),
-    assistantVersion: APP_VERSION,
-  };
-  const disabledFlag = getDisabledPluginFlag(plugin, ctx.config);
+  const assistantConfig = getConfig();
+  const disabledFlag = getDisabledPluginFlag(plugin, assistantConfig);
   if (disabledFlag !== undefined) {
     log.info(
       { plugin: pluginName, flag: disabledFlag },
@@ -535,7 +556,7 @@ export async function reregisterExternalPlugin(
   const existing = getRegisteredPlugin(pluginName);
   if (existing === undefined) {
     try {
-      await initializePlugin(plugin, ctx);
+      await initializePlugin(plugin, assistantConfig);
       setRegisteredPlugin(plugin);
       log.info({ plugin: pluginName }, "external plugin registered post-boot");
     } catch (err) {

package/src/daemon/first-greeting.ts

@@ -43,6 +43,28 @@ export function getCannedFirstGreeting(
   return CANNED_FIRST_GREETING;
 }
 
+/**
+ * Builds a natural self-introduction to send *on behalf of the user* in place
+ * of the wake-up greeting, so the assistant generates a real response instead
+ * of replaying canned copy. Names come from the onboarding context; missing
+ * names are dropped so the line stays natural:
+ *   - both:           "Hi Vela, I'm alex. Nice to meet you."
+ *   - assistant only: "Hi Vela. Nice to meet you."
+ *   - user only:      "Hi, I'm alex. Nice to meet you."
+ * When neither name is known there is nothing personal to say, so this returns
+ * `undefined` and the caller falls back to the canned greeting.
+ */
+export function buildSelfIntroMessage(
+  onboarding?: OnboardingGreetingContext,
+): string | undefined {
+  const assistant = onboarding?.assistantName?.trim();
+  const user = onboarding?.userName?.trim();
+  if (!assistant && !user) return undefined;
+  const hi = assistant ? `Hi ${assistant}` : "Hi";
+  const intro = user ? `, I'm ${user}` : "";
+  return `${hi}${intro}. Nice to meet you.`;
+}
+
 const TONE_INTRO_CLOSE: Record<Tone, string> = {
   grounded: "",
   warm: "Good to meet you.",
@@ -79,12 +101,12 @@ const TONE_INVITE_OPENER: Record<Tone, string> = {
 
 const TONE_MIGRATION_OFFER: Record<Tone, string> = {
   grounded:
-    "If you have context or workflows from another assistant or harness, bring them over early and I'll help port them.",
-  warm: "If you have context or workflows from another assistant or harness, bring them over early and I can help port them.",
+    "And you don't have to start me from scratch — if you've built up a ChatGPT or Claude, bring it over and I'll learn from it fast. Best head start you can give me.",
+  warm: "And you don't have to start me from scratch — if there's a ChatGPT or Claude that already knows you, bring it over and I'll get up to speed fast. Honestly, it's the best head start you could give me.",
   energetic:
-    "If you've got context or workflows from another assistant or harness, bring them over early and I'll port them with you. What sounds right?",
+    "And you don't have to start me from scratch — if you've built up a ChatGPT or Claude, bring it over and I'll get up to speed fast. Best head start you can give me — want to start there?",
   poetic:
-    "If there's old context or workflows from another assistant or harness, bring them over early and I'll help port them.",
+    "And you don't have to start me from nothing — if there's a ChatGPT or Claude that already knows you, bring it over and I'll learn from it. The best head start you could give me.",
 };
 
 const TONE_GOOGLE_SCAN: Record<Tone, string> = {

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

@@ -44,9 +44,9 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
 
     const response = await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: prompt }] }],
-      [],
-      GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
       {
+        tools: [],
+        systemPrompt: GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
         config: {
           max_tokens: options.maxTokens ?? GUARDIAN_ACTION_COPY_MAX_TOKENS,
           callSite: "guardianQuestionCopy",

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

@@ -10,6 +10,8 @@
  * - acceptA2AInvite()  — self-hosted broker: orchestrate complete + redeem across daemons
  */
 
+import { z } from "zod";
+
 import {
   getConfig,
   invalidateConfigCache,
@@ -38,42 +40,55 @@ const log = getLogger("config-a2a");
 
 // ── Result types ────────────────────────────────────────────────────
 
-export interface A2AConfigResult {
-  success: boolean;
-  enabled: boolean;
-  activeConnections: number;
-  error?: string;
-}
-
-export interface CreateA2AInviteResult {
-  success: boolean;
-  inviteId?: string;
-  token?: string;
-  expiresAt?: number;
-  senderGatewayUrl?: string;
-  error?: string;
-}
-
-export interface CompleteA2AInviteResult {
-  success: boolean;
-  sender?: { assistantId: string; displayName: string; gatewayUrl: string };
-  error?: string;
-}
-
-export interface RedeemA2AInviteResult {
-  success: boolean;
-  contactId?: string;
-  alreadyConnected?: boolean;
-  error?: string;
-}
-
-export interface AcceptA2AInviteResult {
-  success: boolean;
-  contactId?: string;
-  alreadyConnected?: boolean;
-  error?: string;
-  errorCode?: string;
-}
+export const A2AConfigResultSchema = z.object({
+  success: z.boolean(),
+  enabled: z.boolean(),
+  activeConnections: z.number(),
+  error: z.string().optional(),
+});
+export type A2AConfigResult = z.infer<typeof A2AConfigResultSchema>;
+
+export const CreateA2AInviteResultSchema = z.object({
+  success: z.boolean(),
+  inviteId: z.string().optional(),
+  token: z.string().optional(),
+  expiresAt: z.number().optional(),
+  senderGatewayUrl: z.string().optional(),
+  error: z.string().optional(),
+});
+export type CreateA2AInviteResult = z.infer<typeof CreateA2AInviteResultSchema>;
+
+export const CompleteA2AInviteResultSchema = z.object({
+  success: z.boolean(),
+  sender: z
+    .object({
+      assistantId: z.string(),
+      displayName: z.string(),
+      gatewayUrl: z.string(),
+    })
+    .optional(),
+  error: z.string().optional(),
+});
+export type CompleteA2AInviteResult = z.infer<
+  typeof CompleteA2AInviteResultSchema
+>;
+
+export const RedeemA2AInviteResultSchema = z.object({
+  success: z.boolean(),
+  contactId: z.string().optional(),
+  alreadyConnected: z.boolean().optional(),
+  error: z.string().optional(),
+});
+export type RedeemA2AInviteResult = z.infer<typeof RedeemA2AInviteResultSchema>;
+
+export const AcceptA2AInviteResultSchema = z.object({
+  success: z.boolean(),
+  contactId: z.string().optional(),
+  alreadyConnected: z.boolean().optional(),
+  error: z.string().optional(),
+  errorCode: z.string().optional(),
+});
+export type AcceptA2AInviteResult = z.infer<typeof AcceptA2AInviteResultSchema>;
 
 // ── Config operations ───────────────────────────────────────────────
 

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

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 import {
   getConfig,
   invalidateConfigCache,
@@ -26,20 +28,24 @@ import { log as _log } from "./shared.js";
 
 // -- Result type --
 
-export interface SlackChannelConfigResult {
-  success: boolean;
-  hasBotToken: boolean;
-  hasAppToken: boolean;
-  hasUserToken: boolean;
-  connected: boolean;
-  teamId?: string;
-  teamName?: string;
-  teamUrl?: string;
-  botUserId?: string;
-  botUsername?: string;
-  error?: string;
-  warning?: string;
-}
+export const SlackChannelConfigResultSchema = z.object({
+  success: z.boolean(),
+  hasBotToken: z.boolean(),
+  hasAppToken: z.boolean(),
+  hasUserToken: z.boolean(),
+  connected: z.boolean(),
+  teamId: z.string().optional(),
+  teamName: z.string().optional(),
+  teamUrl: z.string().optional(),
+  botUserId: z.string().optional(),
+  botUsername: z.string().optional(),
+  error: z.string().optional(),
+  warning: z.string().optional(),
+});
+
+export type SlackChannelConfigResult = z.infer<
+  typeof SlackChannelConfigResultSchema
+>;
 
 // -- Helpers --
 

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

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 import { getIsPlatform } from "../../config/env-registry.js";
 import {
   invalidateConfigCache,
@@ -26,7 +28,6 @@ import {
   deleteCredentialMetadata,
   upsertCredentialMetadata,
 } from "../../tools/credentials/metadata-store.js";
-import type { TelegramConfigResponse } from "../message-protocol.js";
 import { log } from "./shared.js";
 
 const TELEGRAM_BOT_TOKEN_IN_URL_PATTERN =
@@ -60,7 +61,20 @@ function summarizeTelegramError(err: unknown): string {
 
 // -- Transport-agnostic result type (omits the `type` discriminant) --
 
-export type TelegramConfigResult = Omit<TelegramConfigResponse, "type">;
+export const TelegramConfigResultSchema = z.object({
+  success: z.boolean(),
+  hasBotToken: z.boolean(),
+  botId: z.string().optional(),
+  botUsername: z.string().optional(),
+  connected: z.boolean(),
+  hasWebhookSecret: z.boolean(),
+  lastError: z.string().optional(),
+  error: z.string().optional(),
+  commandsRegistered: z.array(z.string()).optional(),
+  warning: z.string().optional(),
+});
+
+export type TelegramConfigResult = z.infer<typeof TelegramConfigResultSchema>;
 
 // -- Extracted business logic functions --
 

package/src/daemon/handlers/conversations.ts

@@ -3,15 +3,16 @@ import { v4 as uuid } from "uuid";
 import { clearAll, getConversation } from "../../memory/conversation-crud.js";
 import { resolveConversationId } from "../../memory/conversation-key-store.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
-import * as pendingInteractions from "../../runtime/pending-interactions.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { createAbortReason } from "../../util/abort-reasons.js";
 import { truncate } from "../../util/truncate.js";
 import { regenerate } from "../conversation-history.js";
 import {
-  clearAllActiveConversations,
   conversationEntries,
   findConversation,
+} from "../conversation-registry.js";
+import {
+  clearAllActiveConversations,
   getOrCreateConversation,
   touchConversation,
 } from "../conversation-store.js";
@@ -28,23 +29,11 @@ export function handleConfirmationResponse(msg: ConfirmationResponse): void {
   for (const [conversationId, conversation] of conversationEntries()) {
     if (conversation.hasPendingConfirmation(msg.requestId)) {
       touchConversation(conversationId);
-      conversation.handleConfirmationResponse(
-        msg.requestId,
-        decision,
-        msg.selectedPattern,
-        msg.selectedScope,
-        undefined,
-        { source: "button" },
-      );
-      // Idempotent cleanup: the prompter's `resolveConfirmation` already
-      // resolved the interaction with the correct approved/rejected state
-      // before we reach here, so the entry is typically gone. This call is
-      // a safety net for paths where the prompter no-ops; map decision to
-      // state to keep the emitted event accurate when it does fire.
-      pendingInteractions.resolve(
-        msg.requestId,
-        decision === "allow" ? "approved" : "rejected",
-      );
+      conversation.handleConfirmationResponse(msg.requestId, decision, {
+        selectedPattern: msg.selectedPattern,
+        selectedScope: msg.selectedScope,
+        emissionContext: { source: "button" },
+      });
       return;
     }
   }
@@ -225,10 +214,7 @@ export function steerToMessage(
   | { steered: true }
   | {
       steered: false;
-      reason:
-        | "conversation_not_found"
-        | "message_not_found"
-        | "not_processing";
+      reason: "conversation_not_found" | "message_not_found" | "not_processing";
     } {
   const conversation = findConversation(conversationId);
   if (!conversation) {