@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/daemon/plugin-source-watcher.ts

@@ -1,278 +0,0 @@
-/**
- * Filesystem watcher for the external plugins directory.
- *
- * Watches `<workspaceDir>/plugins/` recursively using fs.watch (FSEvents on
- * macOS). When a plugin directory is created or modified, debounces per
- * top-level directory name (= the plugin name) and dispatches to the
- * watcher's internal change handler so the daemon can register or reload
- * the plugin without a restart.
- *
- * Mirrors `app-source-watcher.ts` (same DebouncerMap shape, same start/stop
- * lifecycle, same ensureStarted late-create hook), but exposes its lifecycle
- * through a static singleton so tool side-effects can call
- * `PluginSourceWatcher.getInstance().ensureStarted()` directly without an
- * intermediate module-level injection.
- *
- * ## Linux/Bun recursive-watch caveat
- *
- * `fs.watch(dir, { recursive: true })` on Linux (and the equivalent under
- * Bun, which uses the platform inotify path) does **not** dynamically
- * attach to subdirectories created after the watch was established. The
- * kernel fires exactly one event when the new top-level entry appears,
- * and any writes inside that new subtree are silently dropped.
- *
- * Reproducer (against an empty watched root):
- *
- *     mkdir plugin/                      → event "plugin"
- *     mkdir plugin/hooks/                → no event delivered
- *     echo x > plugin/hooks/file.ts      → no event delivered
- *
- * To work around this we close + reopen the watcher on every event (with
- * a coalescing debounce). Reopening walks the tree from scratch and
- * re-subscribes to every directory that currently exists, so subsequent
- * writes anywhere under the new subtree are delivered normally. We also
- * rescan top-level entries after the swap and dispatch a rebuild for any
- * plugin not yet in the registry, which closes the close→reopen gap.
- */
-
-import { type FSWatcher, mkdirSync, readdirSync, watch } from "node:fs";
-
-import { getRegisteredPlugin } from "../plugins/registry.js";
-import { DebouncerMap } from "../util/debounce.js";
-import { getLogger } from "../util/logger.js";
-import { getWorkspacePluginsDir } from "../util/platform.js";
-import { reregisterExternalPlugin } from "./external-plugins-bootstrap.js";
-
-const log = getLogger("plugin-source-watcher");
-
-const PLUGIN_SOURCE_DEBOUNCE_MS = 500;
-
-/**
- * Single shared debouncer key for the "restart the watcher" path. Bursty
- * events for many plugin names all collapse to one restart.
- */
-const WATCHER_RESTART_KEY = "__restart__";
-
-/**
- * Extract the plugin's top-level directory name from a relative path within
- * the plugins root. Returns null for a stray file directly in `plugins/`
- * (not a plugin dir).
- */
-function resolvePluginNameFromRelPath(relPath: string): string | null {
-  const slashIdx = relPath.indexOf("/");
-  if (slashIdx === -1) {
-    // Bare entry under plugins/ — fs.watch reports these when a new
-    // directory is first created. We treat the name as the plugin name and
-    // let the install path decide whether it's a real plugin.
-    if (relPath.length === 0 || relPath.startsWith(".")) return null;
-    return relPath;
-  }
-  const dirName = relPath.slice(0, slashIdx);
-  if (dirName.length === 0 || dirName.startsWith(".")) return null;
-  return dirName;
-}
-
-export class PluginSourceWatcher {
-  /**
-   * Process-wide singleton. Callers reach the watcher via
-   * {@link PluginSourceWatcher.getInstance} rather than instantiating
-   * directly so tool side-effects (`assistant plugins install`) can call
-   * `ensureStarted()` on the same watcher the daemon `start()`/`stop()`
-   * lifecycle owns, without threading an instance through a registered
-   * module-level callback.
-   */
-  private static singleton: PluginSourceWatcher | null = null;
-
-  static getInstance(): PluginSourceWatcher {
-    PluginSourceWatcher.singleton ??= new PluginSourceWatcher();
-    return PluginSourceWatcher.singleton;
-  }
-
-  /** Test-only — drops the singleton so the next `getInstance()` rebuilds. */
-  static resetForTests(): void {
-    PluginSourceWatcher.singleton?.stop();
-    PluginSourceWatcher.singleton = null;
-  }
-
-  private watcher: FSWatcher | null = null;
-  private started = false;
-  private debouncer = new DebouncerMap({
-    defaultDelayMs: PLUGIN_SOURCE_DEBOUNCE_MS,
-    maxEntries: 50,
-  });
-  /**
-   * Coalesces watcher-restart requests across bursty events. See
-   * {@link restartWatcher} for why we restart on every event.
-   */
-  private restartDebouncer = new DebouncerMap({
-    defaultDelayMs: PLUGIN_SOURCE_DEBOUNCE_MS,
-    maxEntries: 1,
-  });
-
-  start(): void {
-    this.started = true;
-    this.tryWatch();
-  }
-
-  /**
-   * Ensure the watcher is running. Idempotent — safe to call after a tool
-   * side-effect that may have just created the plugins directory.
-   * No-op if `start()` has not been called yet.
-   */
-  ensureStarted(): void {
-    if (!this.started || this.watcher) return;
-    this.tryWatch();
-  }
-
-  stop(): void {
-    this.started = false;
-    this.debouncer.cancelAll();
-    this.restartDebouncer.cancelAll();
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-  }
-
-  private onChange(pluginName: string): Promise<void> {
-    return reregisterExternalPlugin(pluginName);
-  }
-
-  /**
-   * Close the current FSWatcher and open a fresh one on the same root.
-   *
-   * Workaround for the Linux/Bun recursive-watch limitation documented at
-   * the top of this file. Reopening re-walks the tree and re-subscribes
-   * to every directory that exists at that moment, including any subtree
-   * that grew under the watched root since the previous watcher started.
-   *
-   * Belt-and-suspenders: after the swap, we rescan top-level entries and
-   * dispatch a rebuild for any plugin not yet in the registry — this
-   * closes the (sub-millisecond) gap between close and reopen during
-   * which a brand-new plugin's first event could be lost.
-   *
-   * Failure mode: if the reopen fails, keep the previous watcher active.
-   * It may still miss newly-created subtrees, but it preserves existing
-   * plugin source coverage instead of degrading to no watcher at all.
-   */
-  private restartWatcher(): void {
-    if (!this.started) return;
-
-    const oldWatcher = this.watcher;
-    this.watcher = null; // tryWatch returns early when non-null
-    this.tryWatch();
-
-    if (this.watcher === null) {
-      // Keep the previous watcher alive if the replacement failed. It may not
-      // cover newly-created subtrees, but it is still better than dropping all
-      // plugin source coverage.
-      this.watcher = oldWatcher;
-      log.warn(
-        "Plugin source watcher restart failed; keeping previous watcher active",
-      );
-      return;
-    }
-
-    if (oldWatcher) {
-      try {
-        oldWatcher.close();
-      } catch (err) {
-        log.warn({ err }, "Failed to close previous plugin watcher");
-      }
-    }
-
-    this.rescanPlugins();
-  }
-
-  /**
-   * Schedule a rebuild for every top-level entry under the plugins dir
-   * that isn't already in the registry. Called after a successful
-   * {@link restartWatcher} to catch new-plugin events that may have been
-   * lost during the close→reopen swap.
-   *
-   * Existing plugins are skipped — their normal change events are
-   * delivered through the freshly-attached watcher.
-   */
-  private rescanPlugins(): void {
-    let pluginsDir: string;
-    try {
-      pluginsDir = getWorkspacePluginsDir();
-    } catch {
-      return;
-    }
-
-    let entries: string[];
-    try {
-      entries = readdirSync(pluginsDir);
-    } catch (err) {
-      log.warn({ err, pluginsDir }, "Failed to rescan plugins directory");
-      return;
-    }
-
-    for (const entry of entries) {
-      // Skip dotfiles / dot-directories (e.g. macOS `.DS_Store`, npm cache).
-      if (entry.startsWith(".")) continue;
-      // Existing plugins ride the watcher's normal event delivery. The
-      // rescan is purely to catch installs whose first event was lost.
-      if (getRegisteredPlugin(entry) !== undefined) continue;
-      this.debouncer.schedule(`plugin:${entry}`, () => {
-        void this.onChange(entry);
-      });
-    }
-  }
-
-  private tryWatch(): void {
-    if (this.watcher) return;
-
-    let pluginsDir: string;
-    try {
-      pluginsDir = getWorkspacePluginsDir();
-    } catch {
-      log.warn(
-        "Could not resolve plugins directory; plugin source watching disabled",
-      );
-      return;
-    }
-
-    try {
-      mkdirSync(pluginsDir, { recursive: true });
-    } catch (err) {
-      log.warn(
-        { err, pluginsDir },
-        "Could not create plugins directory; source watching disabled",
-      );
-      return;
-    }
-
-    try {
-      this.watcher = watch(
-        pluginsDir,
-        { recursive: true },
-        (_eventType, filename) => {
-          if (!filename) return;
-          const pluginName = resolvePluginNameFromRelPath(filename);
-          if (!pluginName) return;
-
-          // Per-plugin rebuild — debounced under the plugin name so bursty
-          // edits collapse to a single rebuild.
-          this.debouncer.schedule(`plugin:${pluginName}`, () => {
-            void this.onChange(pluginName);
-          });
-
-          // Refresh the watcher to pick up any subtree that grew under us.
-          // Coalesced across all plugin names; single watcher restart per
-          // event burst. See restartWatcher for the rationale.
-          this.restartDebouncer.schedule(WATCHER_RESTART_KEY, () => {
-            this.restartWatcher();
-          });
-        },
-      );
-      log.info({ pluginsDir }, "Plugin source watcher started");
-    } catch (err) {
-      log.warn(
-        { err },
-        "Failed to watch plugins directory; source watching disabled",
-      );
-    }
-  }
-}

package/src/daemon/switch-inference-profile-tool.ts

@@ -1,62 +0,0 @@
-import type { ProfileEntry } from "../config/schemas/llm.js";
-import { AUTO_PROFILE_KEY } from "../config/seed-inference-profiles.js";
-import type { ToolDefinition } from "../providers/types.js";
-
-export const SWITCH_INFERENCE_PROFILE_TOOL_NAME = "switch_inference_profile";
-
-const PROFILE_DESCRIPTION_FALLBACKS: Record<string, string> = {
-  "quality-optimized":
-    "Most capable model for complex reasoning, multi-step analysis, math, and coding",
-  balanced: "Good balance of quality, cost, and speed for most tasks",
-  "cost-optimized":
-    "Fast responses for simple factual questions, short lookups, and casual chat",
-};
-
-export function buildSwitchInferenceProfileToolDef(
-  profiles: Record<string, ProfileEntry>,
-  currentProfile?: string,
-): ToolDefinition | null {
-  const entries = Object.entries(profiles).filter(
-    ([key, entry]) =>
-      entry.status !== "disabled" &&
-      key !== AUTO_PROFILE_KEY &&
-      // Mix profiles are A/B-routing buckets, not concrete targets the model
-      // should self-select into — exclude them so the picker only offers real
-      // profiles.
-      entry.mix == null,
-  );
-  if (entries.length < 2) return null;
-
-  const profileDescriptions = entries
-    .map(([key, entry]) => {
-      const label = entry.label ?? key;
-      const desc =
-        entry.description || PROFILE_DESCRIPTION_FALLBACKS[key] || "";
-      const descSuffix = desc ? `: ${desc}` : "";
-      const current = key === currentProfile ? " (current)" : "";
-      return `- ${key} — ${label}${descSuffix}${current}`;
-    })
-    .join("\n");
-
-  const currentEntry = currentProfile ? profiles[currentProfile] : undefined;
-  const currentLabel =
-    currentProfile === AUTO_PROFILE_KEY
-      ? "Auto (starting on Balanced)"
-      : (currentEntry?.label ?? currentProfile ?? "current");
-
-  return {
-    name: SWITCH_INFERENCE_PROFILE_TOOL_NAME,
-    description: `Switch to a different inference profile BEFORE answering. You MUST call this tool when the user's query requires capabilities beyond what your current profile ("${currentLabel}") provides — AND you MUST also call it when the query is trivially simple and a faster, cheaper profile would handle it equally well.\n\nSwitch UP (to a more capable profile) for: multi-step reasoning or analysis, math proofs or derivations, complex coding tasks, detailed creative writing, or any task requiring deep thought.\n\nSwitch DOWN (to a faster profile) for: simple greetings or chitchat, one-word or single-sentence answers, factual lookups, acknowledgments, or any query that does not benefit from advanced reasoning.\n\nWhen in doubt about whether you can handle the query well, switch UP. When in doubt about whether the query is too simple for your current profile, switch DOWN.\n\nAvailable profiles:\n${profileDescriptions}`,
-    input_schema: {
-      type: "object" as const,
-      properties: {
-        profile: {
-          type: "string",
-          enum: entries.map(([key]) => key),
-          description: "The profile key to switch to.",
-        },
-      },
-      required: ["profile"],
-    },
-  };
-}

package/src/memory/guardian-approvals.ts

@@ -1,361 +0,0 @@
-/**
- * Guardian approval request tracking.
- *
- * Approval requests track per-run guardian approval decisions — whether
- * a guardian has approved or denied a tool invocation on behalf of a
- * channel requester.
- */
-
-import { and, desc, eq, gt, lte } from "drizzle-orm";
-import { v4 as uuid } from "uuid";
-
-import { getDb } from "./db-connection.js";
-import { channelGuardianApprovalRequests } from "./schema.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type ApprovalRequestStatus =
-  | "pending"
-  | "approved"
-  | "denied"
-  | "expired"
-  | "cancelled";
-
-export interface GuardianApprovalRequest {
-  id: string;
-  runId: string;
-  requestId: string;
-  conversationId: string;
-  channel: string;
-  requesterExternalUserId: string;
-  requesterChatId: string;
-  guardianExternalUserId: string;
-  guardianChatId: string;
-  toolName: string;
-  riskLevel: string | null;
-  reason: string | null;
-  status: ApprovalRequestStatus;
-  decidedByExternalUserId: string | null;
-  expiresAt: number;
-  createdAt: number;
-  updatedAt: number;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function rowToApprovalRequest(
-  row: typeof channelGuardianApprovalRequests.$inferSelect,
-): GuardianApprovalRequest {
-  return {
-    id: row.id,
-    runId: row.runId,
-    requestId: row.requestId ?? row.runId,
-    conversationId: row.conversationId,
-    channel: row.channel,
-    requesterExternalUserId: row.requesterExternalUserId,
-    requesterChatId: row.requesterChatId,
-    guardianExternalUserId: row.guardianExternalUserId,
-    guardianChatId: row.guardianChatId,
-    toolName: row.toolName,
-    riskLevel: row.riskLevel,
-    reason: row.reason,
-    status: row.status as ApprovalRequestStatus,
-    decidedByExternalUserId: row.decidedByExternalUserId,
-    expiresAt: row.expiresAt,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Operations
-// ---------------------------------------------------------------------------
-
-/**
- * @internal Test-only helper. Production code should create guardian requests
- * via `createCanonicalGuardianRequest` in canonical-guardian-store.ts.
- * This function is retained solely so that existing test fixtures that seed
- * legacy approval rows continue to compile.
- */
-export function createApprovalRequest(params: {
-  runId: string;
-  requestId?: string;
-  conversationId: string;
-  channel: string;
-  requesterExternalUserId: string;
-  requesterChatId: string;
-  guardianExternalUserId: string;
-  guardianChatId: string;
-  toolName: string;
-  riskLevel?: string;
-  reason?: string;
-  expiresAt: number;
-}): GuardianApprovalRequest {
-  const db = getDb();
-  const now = Date.now();
-  const id = uuid();
-
-  const row = {
-    id,
-    runId: params.runId,
-    requestId: params.requestId ?? null,
-    conversationId: params.conversationId,
-    channel: params.channel,
-    requesterExternalUserId: params.requesterExternalUserId,
-    requesterChatId: params.requesterChatId,
-    guardianExternalUserId: params.guardianExternalUserId,
-    guardianChatId: params.guardianChatId,
-    toolName: params.toolName,
-    riskLevel: params.riskLevel ?? null,
-    reason: params.reason ?? null,
-    status: "pending" as const,
-    decidedByExternalUserId: null,
-    expiresAt: params.expiresAt,
-    createdAt: now,
-    updatedAt: now,
-  };
-
-  db.insert(channelGuardianApprovalRequests).values(row).run();
-
-  return rowToApprovalRequest(row);
-}
-
-export function getPendingApprovalForRequest(
-  requestId: string,
-): GuardianApprovalRequest | null {
-  const db = getDb();
-  const now = Date.now();
-
-  const row = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(
-      and(
-        eq(channelGuardianApprovalRequests.requestId, requestId),
-        eq(channelGuardianApprovalRequests.status, "pending"),
-        gt(channelGuardianApprovalRequests.expiresAt, now),
-      ),
-    )
-    .get();
-
-  return row ? rowToApprovalRequest(row) : null;
-}
-
-export function getUnresolvedApprovalForRequest(
-  requestId: string,
-): GuardianApprovalRequest | null {
-  const db = getDb();
-
-  const row = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(
-      and(
-        eq(channelGuardianApprovalRequests.requestId, requestId),
-        eq(channelGuardianApprovalRequests.status, "pending"),
-      ),
-    )
-    .get();
-
-  return row ? rowToApprovalRequest(row) : null;
-}
-
-/**
- * Find a pending guardian approval request by the guardian's chat ID.
- * Used when the guardian sends a decision from their chat.
- */
-export function getPendingApprovalByGuardianChat(
-  channel: string,
-  guardianChatId: string,
-): GuardianApprovalRequest | null {
-  const db = getDb();
-  const now = Date.now();
-
-  const row = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(
-      and(
-        eq(channelGuardianApprovalRequests.channel, channel),
-        eq(channelGuardianApprovalRequests.guardianChatId, guardianChatId),
-        eq(channelGuardianApprovalRequests.status, "pending"),
-        gt(channelGuardianApprovalRequests.expiresAt, now),
-      ),
-    )
-    .orderBy(desc(channelGuardianApprovalRequests.createdAt))
-    .get();
-
-  return row ? rowToApprovalRequest(row) : null;
-}
-
-/**
- * Find a pending guardian approval request scoped to a specific requestId,
- * guardian chat, and channel. Used when a callback button provides a requestId,
- * so the decision is applied to exactly the right approval even when
- * multiple approvals target the same guardian chat.
- */
-export function getPendingApprovalByRequestAndGuardianChat(
-  requestId: string,
-  channel: string,
-  guardianChatId: string,
-): GuardianApprovalRequest | null {
-  const db = getDb();
-  const now = Date.now();
-
-  const row = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(
-      and(
-        eq(channelGuardianApprovalRequests.requestId, requestId),
-        eq(channelGuardianApprovalRequests.channel, channel),
-        eq(channelGuardianApprovalRequests.guardianChatId, guardianChatId),
-        eq(channelGuardianApprovalRequests.status, "pending"),
-        gt(channelGuardianApprovalRequests.expiresAt, now),
-      ),
-    )
-    .get();
-
-  return row ? rowToApprovalRequest(row) : null;
-}
-
-/**
- * Return all pending (non-expired) guardian approval requests for a given
- * guardian chat and channel. Used to detect ambiguity when a guardian sends
- * a plain-text decision while multiple approvals are pending.
- */
-export function getAllPendingApprovalsByGuardianChat(
-  channel: string,
-  guardianChatId: string,
-): GuardianApprovalRequest[] {
-  const db = getDb();
-  const now = Date.now();
-
-  const rows = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(
-      and(
-        eq(channelGuardianApprovalRequests.channel, channel),
-        eq(channelGuardianApprovalRequests.guardianChatId, guardianChatId),
-        eq(channelGuardianApprovalRequests.status, "pending"),
-        gt(channelGuardianApprovalRequests.expiresAt, now),
-      ),
-    )
-    .orderBy(desc(channelGuardianApprovalRequests.createdAt))
-    .all();
-
-  return rows.map(rowToApprovalRequest);
-}
-
-/**
- * Return all pending approval requests whose expiresAt has passed.
- * Used by the proactive expiry sweep to auto-deny expired approvals
- * without waiting for requester follow-up traffic.
- */
-export function getExpiredPendingApprovals(): GuardianApprovalRequest[] {
-  const db = getDb();
-  const now = Date.now();
-
-  const rows = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(
-      and(
-        eq(channelGuardianApprovalRequests.status, "pending"),
-        lte(channelGuardianApprovalRequests.expiresAt, now),
-      ),
-    )
-    .all();
-
-  return rows.map(rowToApprovalRequest);
-}
-
-export function updateApprovalDecision(
-  id: string,
-  decision: { status: ApprovalRequestStatus; decidedByExternalUserId?: string },
-): void {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(channelGuardianApprovalRequests)
-    .set({
-      status: decision.status,
-      decidedByExternalUserId: decision.decidedByExternalUserId ?? null,
-      updatedAt: now,
-    })
-    .where(eq(channelGuardianApprovalRequests.id, id))
-    .run();
-}
-
-/**
- * Fetch a single approval request by its primary key.
- */
-export function getApprovalRequestById(
-  id: string,
-): GuardianApprovalRequest | null {
-  const db = getDb();
-
-  const row = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(eq(channelGuardianApprovalRequests.id, id))
-    .get();
-
-  return row ? rowToApprovalRequest(row) : null;
-}
-
-/**
- * Resolve a pending approval request with a decision.
- *
- * Idempotent: if the request is already resolved with the same decision,
- * the existing record is returned unchanged. Returns null if the request
- * does not exist or was resolved with a *different* decision.
- */
-export function resolveApprovalRequest(
-  id: string,
-  decision: "approved" | "denied",
-  decidedByExternalUserId?: string,
-): GuardianApprovalRequest | null {
-  const db = getDb();
-
-  const existing = db
-    .select()
-    .from(channelGuardianApprovalRequests)
-    .where(eq(channelGuardianApprovalRequests.id, id))
-    .get();
-
-  if (!existing) return null;
-
-  // Idempotent: already resolved with the same decision
-  if (existing.status === decision) {
-    return rowToApprovalRequest(existing);
-  }
-
-  // Only resolve if currently pending
-  if (existing.status !== "pending") {
-    return null;
-  }
-
-  const now = Date.now();
-
-  db.update(channelGuardianApprovalRequests)
-    .set({
-      status: decision,
-      decidedByExternalUserId: decidedByExternalUserId ?? null,
-      updatedAt: now,
-    })
-    .where(eq(channelGuardianApprovalRequests.id, id))
-    .run();
-
-  return rowToApprovalRequest({
-    ...existing,
-    status: decision,
-    decidedByExternalUserId: decidedByExternalUserId ?? null,
-    updatedAt: now,
-  });
-}