@vellumai/assistant 0.6.6 → 0.7.1

package/src/daemon/daemon-control.ts

@@ -138,7 +138,7 @@ function isVellumDaemonProcess(pid: number): boolean {
  *  Wildcard addresses (0.0.0.0, ::) bind all interfaces but aren't
  *  connectable on all platforms — substitute loopback. IPv6 literals
  *  need brackets in URLs. */
-export function healthCheckHost(host: string): string {
+function healthCheckHost(host: string): string {
   if (host === "0.0.0.0") return "127.0.0.1";
   if (host === "::") return "[::1]";
   if (host.includes(":")) return `[${host}]`;
@@ -148,7 +148,7 @@ export function healthCheckHost(host: string): string {
 /** Hit the daemon's HTTP /healthz endpoint. Returns true if it responds
  *  with HTTP 200 within the timeout — false on connection refused, timeout,
  *  or any other error. */
-export async function isHttpHealthy(): Promise<boolean> {
+async function isHttpHealthy(): Promise<boolean> {
   const host = healthCheckHost(getRuntimeHttpHost());
   const port = getRuntimeHttpPort();
   try {
@@ -207,7 +207,7 @@ export function isDaemonRunning(): boolean {
   return true;
 }
 
-export async function getDaemonStatus(): Promise<{
+async function getDaemonStatus(): Promise<{
   running: boolean;
   pid?: number;
 }> {
@@ -287,7 +287,7 @@ function releaseStartupLock(): void {
 // NOTE: startDaemon() is the assistant-side daemon lifecycle manager.
 // It should eventually converge with cli/src/lib/local.ts::startLocalDaemon
 // which is the CLI-side equivalent.
-export async function startDaemon(): Promise<{
+async function startDaemon(): Promise<{
   pid: number;
   alreadyRunning: boolean;
 }> {
@@ -447,74 +447,6 @@ export type StopResult =
   | { stopped: true }
   | { stopped: false; reason: "not_running" | "stop_failed" };
 
-export async function stopDaemon(): Promise<StopResult> {
-  const pid = readPid();
-  if (pid == null || !isProcessRunning(pid)) {
-    cleanupPidFile();
-    return { stopped: false, reason: "not_running" };
-  }
-
-  // Guard against stale PID reuse: if the PID has been recycled by the OS
-  // and now belongs to an unrelated process, clean up the PID file but
-  // never signal it.
-  if (!isVellumDaemonProcess(pid)) {
-    log.info(
-      { pid },
-      "PID file references a non-vellum process (stale PID reuse) — cleaning up PID file only",
-    );
-    cleanupPidFile();
-    return { stopped: false, reason: "not_running" };
-  }
-
-  process.kill(pid, "SIGTERM");
-
-  const timeouts = readDaemonTimeouts();
-
-  // Wait for process to exit
-  const maxWait = timeouts.stopTimeoutMs;
-  const interval = 100;
-  let waited = 0;
-  while (waited < maxWait) {
-    if (!isProcessRunning(pid)) {
-      cleanupPidFile();
-      return { stopped: true };
-    }
-    await new Promise((r) => setTimeout(r, interval));
-    waited += interval;
-  }
-
-  // Force kill
-  try {
-    process.kill(pid, "SIGKILL");
-  } catch (err) {
-    log.debug({ err, pid }, "SIGKILL failed, process already exited");
-  }
-
-  // Wait for the process to actually die after SIGKILL. Without this,
-  // startDaemon() can race with the dying process's shutdown handler.
-  const killMaxWait = timeouts.sigkillGracePeriodMs;
-  let killWaited = 0;
-  while (killWaited < killMaxWait && isProcessRunning(pid)) {
-    await new Promise((r) => setTimeout(r, 100));
-    killWaited += 100;
-  }
-
-  // Only clean up if the process has actually exited.
-  // If it's still alive after SIGKILL + timeout, preserve the PID file
-  // so isDaemonRunning() still reports true and prevents a duplicate
-  // daemon from being spawned.
-  if (!isProcessRunning(pid)) {
-    cleanupPidFile();
-    return { stopped: true };
-  }
-
-  log.warn(
-    { pid },
-    "Daemon process still running after SIGKILL + timeout, leaving PID file intact",
-  );
-  return { stopped: false, reason: "stop_failed" };
-}
-
 export async function ensureDaemonRunning(): Promise<void> {
   const status = await getDaemonStatus();
   if (status.running) return;

package/src/daemon/daemon-skill-host.ts

@@ -0,0 +1,259 @@
+/**
+ * `DaemonSkillHost` — in-process concretion of the neutral `SkillHost`
+ * interface defined in `@vellumai/skill-host-contracts`.
+ *
+ * `createDaemonSkillHost(skillId)` returns a plain object whose nine facets
+ * (`logger`, `config`, `identity`, `platform`, `providers`, `memory`,
+ * `events`, `registries`, `speakers`) delegate to the daemon's existing
+ * singleton modules. First-party skills that live in-process receive this
+ * host via the bootstrap path instead of reaching into `assistant/` with
+ * relative imports.
+ *
+ * Where a delegate's signature does not line up exactly with the contract
+ * — pino's `(meta, msg)` log methods vs the contract's `(msg, meta)`,
+ * `getAssistantName()` returning `null` vs the contract's `undefined`,
+ * `getProviderKeyAsync()` returning `undefined` vs the contract's `null`,
+ * `buildAssistantEvent()` signature differences, etc. — the
+ * adaptation happens inside this file so the contract stays narrow and the
+ * underlying daemon APIs stay unchanged.
+ */
+
+import type {
+  AssistantEvent,
+  AssistantEventCallback,
+  ConfigFacet,
+  EventsFacet,
+  Filter,
+  IdentityFacet,
+  InsertMessageFn,
+  LlmProvidersFacet,
+  Logger,
+  LoggerFacet,
+  MemoryFacet,
+  PlatformFacet,
+  Provider,
+  ProvidersFacet,
+  RegistriesFacet,
+  SecureKeysFacet,
+  ServerMessage,
+  SkillHost,
+  SkillRoute,
+  SkillRouteHandle,
+  SpeakersFacet,
+  StreamingTranscriber,
+  SttProvidersFacet,
+  Subscription,
+  ToolUse,
+  TtsConfig,
+  TtsProvider,
+  TtsProvidersFacet,
+  UserMessage,
+} from "@vellumai/skill-host-contracts";
+
+import { SpeakerIdentityTracker } from "../calls/speaker-identification.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { getConfig, getNestedValue } from "../config/loader.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import { addMessage } from "../memory/conversation-crud.js";
+import {
+  createTimeout,
+  extractToolUse,
+  getConfiguredProvider,
+  userMessage,
+} from "../providers/provider-send-message.js";
+import {
+  listProviderIds as sttListProviderIds,
+  supportsBoundary as sttSupportsBoundary,
+} from "../providers/speech-to-text/provider-catalog.js";
+import { resolveStreamingTranscriber as sttResolveStreamingTranscriber } from "../providers/speech-to-text/resolve.js";
+import { wakeAgentForOpportunity } from "../runtime/agent-wake.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { getDaemonRuntimeMode } from "../runtime/runtime-mode.js";
+import { registerSkillRoute } from "../runtime/skill-route-registry.js";
+import { getProviderKeyAsync } from "../security/secure-keys.js";
+import { registerExternalTools } from "../tools/registry.js";
+import { getTtsProvider } from "../tts/provider-registry.js";
+import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
+import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir, vellumRoot } from "../util/platform.js";
+import { getAssistantName } from "./identity-helpers.js";
+import { registerShutdownHook } from "./shutdown-registry.js";
+
+/**
+ * Adapt pino's `(meta, msg)` call shape to the contract's `(msg, meta?)`
+ * shape so skills can use `host.logger.get(...).info("msg", { ... })`
+ * without knowing about pino.
+ */
+function adaptLogger(name: string): Logger {
+  const pino = getLogger(name);
+  return {
+    debug: (msg, meta) => pino.debug(meta ?? {}, msg),
+    info: (msg, meta) => pino.info(meta ?? {}, msg),
+    warn: (msg, meta) => pino.warn(meta ?? {}, msg),
+    error: (msg, meta) => pino.error(meta ?? {}, msg),
+  };
+}
+
+function buildLoggerFacet(skillId: string): LoggerFacet {
+  return {
+    get: (name) => adaptLogger(`${skillId}:${name}`),
+  };
+}
+
+function buildConfigFacet(): ConfigFacet {
+  return {
+    isFeatureFlagEnabled: (key) =>
+      isAssistantFeatureFlagEnabled(key, getConfig()),
+    getSection: <T>(path: string): T | undefined =>
+      getNestedValue(
+        getConfig() as unknown as Record<string, unknown>,
+        path,
+      ) as T | undefined,
+  };
+}
+
+function buildIdentityFacet(): IdentityFacet {
+  return {
+    // Contract uses `undefined`; delegate returns `null`. Normalize here.
+    getAssistantName: () => getAssistantName() ?? undefined,
+  };
+}
+
+function buildPlatformFacet(): PlatformFacet {
+  return {
+    workspaceDir: () => getWorkspaceDir(),
+    vellumRoot: () => vellumRoot(),
+    runtimeMode: () => getDaemonRuntimeMode(),
+  };
+}
+
+function buildLlmProvidersFacet(): LlmProvidersFacet {
+  return {
+    getConfigured: async (callSite) =>
+      (await getConfiguredProvider(callSite as LLMCallSite)) as Provider | null,
+    userMessage: (text) => userMessage(text) as unknown as UserMessage,
+    extractToolUse: (response) =>
+      (extractToolUse(response as Parameters<typeof extractToolUse>[0]) ??
+        null) as ToolUse | null,
+    createTimeout,
+  };
+}
+
+function buildSttProvidersFacet(): SttProvidersFacet {
+  return {
+    listProviderIds: () => [...sttListProviderIds()],
+    // Contract asks whether a provider id is usable; we check against the
+    // daemon-streaming boundary which is the only boundary skills currently
+    // care about. Passes the id through to the daemon helper.
+    supportsBoundary: (id) =>
+      sttSupportsBoundary(
+        id as Parameters<typeof sttSupportsBoundary>[0],
+        "daemon-streaming",
+      ),
+    resolveStreamingTranscriber: async (spec) =>
+      (await sttResolveStreamingTranscriber(
+        spec as Parameters<typeof sttResolveStreamingTranscriber>[0],
+      )) as StreamingTranscriber | null,
+  };
+}
+
+function buildTtsProvidersFacet(): TtsProvidersFacet {
+  return {
+    get: (id) => getTtsProvider(id as never) as unknown as TtsProvider,
+    // `resolveTtsConfig` needs the current config; the contract takes no
+    // args, so we fetch `getConfig()` at call time and pass it through.
+    resolveConfig: () => resolveTtsConfig(getConfig()) as unknown as TtsConfig,
+  };
+}
+
+function buildSecureKeysFacet(): SecureKeysFacet {
+  return {
+    // Daemon returns `undefined`; contract returns `null`. Normalize.
+    getProviderKey: async (id) => (await getProviderKeyAsync(id)) ?? null,
+  };
+}
+
+function buildProvidersFacet(): ProvidersFacet {
+  return {
+    llm: buildLlmProvidersFacet(),
+    stt: buildSttProvidersFacet(),
+    tts: buildTtsProvidersFacet(),
+    secureKeys: buildSecureKeysFacet(),
+  };
+}
+
+function buildMemoryFacet(): MemoryFacet {
+  return {
+    addMessage: addMessage as InsertMessageFn,
+    wakeAgentForOpportunity: async (req) => {
+      // Contract returns `void`; daemon returns a `WakeResult` that
+      // in-process callers don't need through the host surface.
+      await wakeAgentForOpportunity(req as never);
+    },
+  };
+}
+
+function buildEventsFacet(): EventsFacet {
+  return {
+    // Contract types events/messages as opaque supersets of the daemon's
+    // narrower discriminated unions; cast at the boundary so
+    // `assistantEventHub` continues to accept its existing type.
+    publish: (event: AssistantEvent) =>
+      assistantEventHub.publish(event as never),
+    subscribe: (filter: Filter, cb: AssistantEventCallback): Subscription =>
+      assistantEventHub.subscribe({
+        type: "process",
+        filter,
+        callback: cb,
+      }),
+    // `buildAssistantEvent` takes `(message, conversationId?)`.
+    buildEvent: (message: ServerMessage, conversationId?: string) =>
+      buildAssistantEvent(message as never, conversationId) as AssistantEvent,
+  };
+}
+
+function buildRegistriesFacet(skillId: string): RegistriesFacet {
+  return {
+    // Contract's `Tool` is structurally independent of the daemon's
+    // overlay (`assistant/src/tools/types.ts`); the assistant-side
+    // registry accepts the daemon flavor. Skills construct tools via
+    // helpers that already produce the daemon shape, so a cast at this
+    // boundary is safe.
+    registerTools: (provider) => registerExternalTools(provider as never),
+    registerSkillRoute: (route: SkillRoute): SkillRouteHandle =>
+      registerSkillRoute(route) as unknown as SkillRouteHandle,
+    // Namespace hook names by skillId so two skills using the same label
+    // (e.g. "cleanup") cannot silently overwrite each other's entries in
+    // the shared shutdown-hook map.
+    registerShutdownHook: (name, hook) =>
+      registerShutdownHook(`${skillId}:${name}`, hook),
+  };
+}
+
+function buildSpeakersFacet(): SpeakersFacet {
+  return {
+    createTracker: () => new SpeakerIdentityTracker(),
+  };
+}
+
+/**
+ * Build a `SkillHost` for the in-process first-party skill identified by
+ * `skillId`. The id prefixes logger names (so cross-cutting diagnostics
+ * carry the owning skill) and namespaces shutdown-hook registrations (so
+ * two skills using the same hook label cannot silently overwrite each
+ * other in the shared shutdown-hook map).
+ */
+export function createDaemonSkillHost(skillId: string): SkillHost {
+  return {
+    logger: buildLoggerFacet(skillId),
+    config: buildConfigFacet(),
+    identity: buildIdentityFacet(),
+    platform: buildPlatformFacet(),
+    providers: buildProvidersFacet(),
+    memory: buildMemoryFacet(),
+    events: buildEventsFacet(),
+    registries: buildRegistriesFacet(skillId),
+    speakers: buildSpeakersFacet(),
+  };
+}

package/src/daemon/dictation-profile-store.ts

@@ -5,15 +5,8 @@
  * atomic-write pattern (write .tmp → rename → chmod).
  */
 
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
@@ -250,18 +243,6 @@ function loadFromDisk(): DictationProfilesConfig {
   }
 }
 
-function saveToDisk(config: DictationProfilesConfig): void {
-  const path = getStorePath();
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  const tmpPath = path + ".tmp." + process.pid;
-  writeFileSync(tmpPath, JSON.stringify(config, null, 2), { mode: 0o600 });
-  renameSync(tmpPath, path);
-  chmodSync(path, 0o600);
-}
-
 // --- Public API ---
 
 export function loadConfig(): DictationProfilesConfig {
@@ -271,11 +252,6 @@ export function loadConfig(): DictationProfilesConfig {
   return cachedConfig;
 }
 
-export function saveConfig(config: DictationProfilesConfig): void {
-  cachedConfig = config;
-  saveToDisk(config);
-}
-
 function isProfileEnabled(profile: DictationProfile): boolean {
   return profile.enabled !== false;
 }

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

@@ -14,8 +14,11 @@
  * 3. For each plugin, consults `manifest.requiresFlag` against
  *    {@link isAssistantFeatureFlagEnabled}. If any listed flag is disabled,
  *    the plugin is skipped wholesale — no `init()`, no tool/route/skill
- *    contributions, and no entry in the shutdown hook. This is the primary
- *    mechanism for shipping experimental plugins behind a feature flag.
+ *    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.
  * 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
@@ -24,7 +27,7 @@
  *    `manifest.config` if the manifest supplies a parser-like validator
  *    (Zod schemas with `.parse()` are supported; anything else is passed
  *    through untouched).
- * 6. Creates `~/.vellum/plugins-data/<plugin>/` on demand for per-plugin
+ * 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
  *    {@link PluginExecutionError} naming the offending plugin and aborts
@@ -60,6 +63,7 @@ import {
 import {
   ASSISTANT_API_VERSIONS,
   getRegisteredPlugins,
+  unregisterPlugin,
 } from "../plugins/registry.js";
 import {
   type Plugin,
@@ -78,7 +82,7 @@ import {
   unregisterPluginTools,
 } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
-import { vellumRoot } from "../util/platform.js";
+import { getWorkspaceDir } from "../util/platform.js";
 import { registerShutdownHook } from "./shutdown-registry.js";
 
 const log = getLogger("plugins-bootstrap");
@@ -157,10 +161,10 @@ function getPluginConfigRaw(
 }
 
 /**
- * Ensure `~/.vellum/plugins-data/<name>/` exists and return its absolute path.
+ * Ensure `<workspaceDir>/plugins-data/<name>/` exists and return its absolute path.
  */
 function ensurePluginStorageDir(pluginName: string): string {
-  const dir = join(vellumRoot(), "plugins-data", pluginName);
+  const dir = join(getWorkspaceDir(), "plugins-data", pluginName);
   mkdirSync(dir, { recursive: true });
   return dir;
 }
@@ -208,6 +212,17 @@ export async function bootstrapPlugins(ctx: DaemonContext): 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
+  // `getMiddlewaresFor` / `getInjectors` don't re-enter an uninitialized
+  // plugin on the next pipeline invocation).
+  async function rollbackPlugin(active: ActivePlugin): Promise<void> {
+    await teardownPlugin(active, "bootstrap-failed");
+    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
@@ -215,7 +230,7 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
   // hook is only registered once the loop completes successfully.
   async function teardownPartialInit(): Promise<void> {
     for (let i = activePlugins.length - 1; i >= 0; i--) {
-      await teardownPlugin(activePlugins[i]!, "bootstrap-failed");
+      await rollbackPlugin(activePlugins[i]!);
     }
   }
 
@@ -239,9 +254,29 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
         { 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.
@@ -287,6 +322,9 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
           );
         }
       }
+      // 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
@@ -319,7 +357,6 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
       // 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.
-      const routeHandles: SkillRouteHandle[] = [];
       if (plugin.routes && plugin.routes.length > 0) {
         for (const route of plugin.routes) {
           routeHandles.push(registerSkillRoute(route));
@@ -358,11 +395,28 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
       log.info({ plugin: name }, "plugin initialized");
     } catch (err) {
-      // Tear down every plugin that already made it through its full init +
-      // contribution phase, in reverse order, before propagating the error.
-      // Without this, the caller would see a partially-wired registry (tools,
-      // routes, skills all live) with no shutdown hook to clean them up, since
-      // `registerShutdownHook` is only called after the loop completes.
+      // 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);
+      }
       await teardownPartialInit();
       throw err;
     }