@vellumai/assistant 0.8.1 → 0.8.3

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -463,6 +463,80 @@ describe("isToolActiveForContext — cross-client exposure for host_browser", ()
   });
 });
 
+describe("isToolActiveForContext — ask_question macOS gating", () => {
+  test("ask_question is active for web client with a connected client", () => {
+    expect(
+      isToolActiveForContext(
+        "ask_question",
+        makeCtx({
+          hasNoClient: false,
+          channelCapabilities: {
+            channel: "web",
+            supportsDynamicUi: true,
+            clientOS: "web",
+          },
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  test("ask_question is NOT active when clientOS is macos", () => {
+    // The macOS client has no UI handler for question_request yet; the tool
+    // is hidden to avoid a 5-minute prompter timeout.
+    expect(
+      isToolActiveForContext(
+        "ask_question",
+        makeCtx({
+          hasNoClient: false,
+          channelCapabilities: {
+            channel: "macos",
+            supportsDynamicUi: true,
+            clientOS: "macos",
+          },
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  test("ask_question is active when channelCapabilities is undefined (backwards-compat)", () => {
+    expect(
+      isToolActiveForContext("ask_question", makeCtx({ hasNoClient: false })),
+    ).toBe(true);
+  });
+
+  test("ask_question is NOT active when hasNoClient is true regardless of clientOS", () => {
+    expect(
+      isToolActiveForContext(
+        "ask_question",
+        makeCtx({
+          hasNoClient: true,
+          channelCapabilities: {
+            channel: "web",
+            supportsDynamicUi: true,
+            clientOS: "web",
+          },
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  test("other client-capability tools (app_open) are NOT affected by the macos gate", () => {
+    expect(
+      isToolActiveForContext(
+        "app_open",
+        makeCtx({
+          hasNoClient: false,
+          channelCapabilities: {
+            channel: "macos",
+            supportsDynamicUi: true,
+            clientOS: "macos",
+          },
+        }),
+      ),
+    ).toBe(true);
+  });
+});
+
 describe("HOST_TOOL_NAMES derivation", () => {
   test("HOST_TOOL_NAMES is derived from HOST_TOOL_TO_CAPABILITY", () => {
     // Sanity check: every tool in the names set has a capability mapping.

package/src/daemon/approval-generators.ts

@@ -1,6 +1,8 @@
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { loadConfig } from "../config/loader.js";
 import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
 import { resolveDefaultProvider } from "../providers/connection-resolution.js";
+import { listProviders } from "../providers/registry.js";
 import type { Provider } from "../providers/types.js";
 import {
   APPROVAL_COPY_MAX_TOKENS,
@@ -16,6 +18,7 @@ import type {
   ApprovalConversationResult,
   ApprovalCopyGenerator,
 } from "../runtime/http-types.js";
+import { ProviderNotConfiguredError } from "../util/errors.js";
 
 // ---------------------------------------------------------------------------
 // Approval conversation generator constants
@@ -142,14 +145,13 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
     // Connection-aware default + per-call routing. `resolveDefaultProvider`
     // throws `ConnectionResolutionError` on hard config errors (missing /
     // unknown / mismatched connection) and returns null on soft credential
-    // failures (vault miss, transient auth) — we treat null as "no
-    // provider available" and throw a domain-specific error below. We do
-    // not pre-gate on `listProviders()` because the default provider lives
-    // behind a `provider_connection` and never appears in the registry's
-    // initialization-time provider list.
+    // failures (missing credential, platform auth unavailable).
     const baseProvider = await resolveDefaultProvider(config);
     if (!baseProvider) {
-      throw new Error("No provider available for approval conversation");
+      const resolved = resolveCallSiteConfig("mainAgent", config.llm);
+      throw new ProviderNotConfiguredError(resolved.provider, listProviders(), {
+        connectionName: resolved.provider_connection,
+      });
     }
     const provider = wrapWithCallSiteRouting(baseProvider, config);
 

package/src/daemon/config-watcher.ts

@@ -4,6 +4,7 @@
  * for changes.
  */
 import {
+  type Dirent,
   existsSync,
   type FSWatcher,
   mkdirSync,
@@ -12,13 +13,12 @@ import {
   watch,
   watchFile,
 } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import type { MemoryCleanupConfig } from "../config/schemas/memory-lifecycle.js";
 import { resetCleanupScheduleThrottle } from "../memory/cleanup-schedule-state.js";
 import { clearEmbeddingBackendCache } from "../memory/embedding-backend.js";
-import { invalidateLlmRequestLogSourceCache } from "../memory/llm-request-log-source.js";
 import { initializeProviders } from "../providers/registry.js";
 import { handleCancelSignal } from "../signals/cancel.js";
 import { handleConversationUndoSignal } from "../signals/conversation-undo.js";
@@ -38,6 +38,25 @@ import { reloadMcpServers } from "./mcp-reload-service.js";
 
 const log = getLogger("config-watcher");
 
+const SKILL_WATCH_SKIPPED_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "__pycache__",
+  ".install-staging",
+  ".cache",
+  ".next",
+  ".turbo",
+  ".venv",
+  "coverage",
+]);
+
+function isSkippedSkillWatchPath(relativePath: string): boolean {
+  if (relativePath === "(unknown)") return false;
+
+  const segments = relativePath.split(/[\\/]+/).filter(Boolean);
+  return segments.some((segment) => SKILL_WATCH_SKIPPED_DIRS.has(segment));
+}
+
 /**
  * Attach a resilient error handler to an FSWatcher so that async errors
  * (e.g. ENXIO when a Unix socket file like `gateway.sock` appears in a
@@ -141,7 +160,6 @@ export class ConfigWatcher {
       return false;
     }
     clearEmbeddingBackendCache();
-    invalidateLlmRequestLogSourceCache();
     // If cleanup retention settings changed, reset the cleanup scheduler
     // throttle so the next worker tick re-enqueues jobs with the new values
     // instead of waiting out the remaining enqueueIntervalMs (default 6h).
@@ -160,6 +178,8 @@ export class ConfigWatcher {
    * Start all file watchers. `onConversationEvict` is called when watched
    * files change and conversations need to be evicted for reload.
    * `onIdentityChanged` is called when IDENTITY.md changes on disk.
+   * `onSkillsChanged` is called after skill directory changes evict
+   * conversations.
    */
   start(
     onConversationEvict: () => void,
@@ -167,6 +187,7 @@ export class ConfigWatcher {
     onSoundsConfigChanged?: () => void,
     onAvatarChanged?: () => void,
     onConfigChanged?: () => void,
+    onSkillsChanged?: () => void,
   ): void {
     // Reset the stopped flag so a stop()→start() cycle on the same
     // instance resumes hot-reload instead of silently bailing in every
@@ -222,7 +243,7 @@ export class ConfigWatcher {
 
     this.startSignalsWatcher();
     this.startUsersWatcher(onConversationEvict);
-    this.startSkillsWatchers(onConversationEvict);
+    this.startSkillsWatchers(onConversationEvict, onSkillsChanged);
   }
 
   stop(): void {
@@ -422,14 +443,20 @@ export class ConfigWatcher {
     }
   }
 
-  private startSkillsWatchers(onConversationEvict: () => void): void {
+  private startSkillsWatchers(
+    onConversationEvict: () => void,
+    onSkillsChanged?: () => void,
+  ): void {
     const skillsDir = getWorkspaceSkillsDir();
     if (!existsSync(skillsDir)) return;
 
     const scheduleSkillsReload = (file: string): void => {
-      this.debounceTimers.schedule(`skills:${file}`, () => {
+      if (isSkippedSkillWatchPath(file)) return;
+
+      this.debounceTimers.schedule("skills:catalog", () => {
         log.info({ file }, "Skill file changed, reloading");
         onConversationEvict();
+        onSkillsChanged?.();
       });
     };
 
@@ -478,43 +505,79 @@ export class ConfigWatcher {
       }
     };
 
-    const refreshChildWatchers = (): void => {
-      const nextChildDirs = new Set<string>();
+    const formatSkillChangeLabel = (
+      dirPath: string,
+      filename: string,
+    ): string => {
+      if (filename === "(unknown)") {
+        const relativeDir = relative(skillsDir, dirPath);
+        return relativeDir || "(unknown)";
+      }
+      const relativeFile = relative(skillsDir, join(dirPath, filename));
+      return relativeFile || filename;
+    };
 
+    const enumerateSkillSubdirectories = (
+      dirPath: string,
+      acc: Set<string>,
+    ): boolean => {
+      let entries: Dirent[];
       try {
-        const entries = readdirSync(skillsDir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (!entry.isDirectory()) continue;
-          const childDir = join(skillsDir, entry.name);
-          nextChildDirs.add(childDir);
-
-          if (childWatchers.has(childDir)) continue;
-
-          const watcher = watchDir(childDir, (filename) => {
-            const label =
-              filename === "(unknown)"
-                ? entry.name
-                : `${entry.name}/${filename}`;
-            scheduleSkillsReload(label);
-          });
-          if (watcher) {
-            childWatchers.set(childDir, watcher);
-          }
-        }
+        entries = readdirSync(dirPath, { withFileTypes: true });
       } catch (err) {
-        log.warn({ err, skillsDir }, "Failed to enumerate skill directories");
+        log.warn({ err, dirPath }, "Failed to enumerate skill directories");
+        return dirPath !== skillsDir;
+      }
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (SKILL_WATCH_SKIPPED_DIRS.has(entry.name)) continue;
+        const childDir = join(dirPath, entry.name);
+        acc.add(childDir);
+        enumerateSkillSubdirectories(childDir, acc);
+      }
+      return true;
+    };
+
+    const closeChildWatcher = (dirPath: string, watcher: FSWatcher): void => {
+      watcher.close();
+      childWatchers.delete(dirPath);
+      removeWatcher(watcher);
+    };
+
+    const refreshChildWatchers = (): void => {
+      const nextChildDirs = new Set<string>();
+      if (!enumerateSkillSubdirectories(skillsDir, nextChildDirs)) {
+        for (const [childDir, watcher] of childWatchers.entries()) {
+          closeChildWatcher(childDir, watcher);
+        }
         return;
       }
 
       for (const [childDir, watcher] of childWatchers.entries()) {
         if (nextChildDirs.has(childDir)) continue;
-        watcher.close();
-        childWatchers.delete(childDir);
-        removeWatcher(watcher);
+        closeChildWatcher(childDir, watcher);
+      }
+
+      for (const childDir of nextChildDirs) {
+        if (childWatchers.has(childDir)) continue;
+
+        const watcher = watchDir(childDir, (filename) => {
+          const file = formatSkillChangeLabel(childDir, filename);
+          if (isSkippedSkillWatchPath(file)) return;
+
+          scheduleSkillsReload(file);
+          refreshChildWatchers();
+        });
+        if (watcher) {
+          childWatchers.set(childDir, watcher);
+        }
       }
     };
 
     const rootWatcher = watchDir(skillsDir, (filename) => {
+      if (isSkippedSkillWatchPath(filename)) return;
+
       scheduleSkillsReload(filename);
       refreshChildWatchers();
     });

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -23,7 +23,9 @@ import {
 } from "../memory/conversation-crud.js";
 import {
   backfillMessageIdOnLogs,
+  buildProviderErrorResponsePayload,
   recordRequestLog,
+  setAgentLoopExitReasonOnLatestLog,
 } from "../memory/llm-request-log-store.js";
 import { backfillMemoryRecallLogMessageId } from "../memory/memory-recall-log-store.js";
 import { backfillMemoryV2ActivationMessageId } from "../memory/memory-v2-activation-log-store.js";
@@ -1166,6 +1168,52 @@ function handleUsage(
   state.llmCallStartedEmitted = false;
 }
 
+/**
+ * Persist a provider-rejected LLM call as an `llm_request_logs` row.
+ *
+ * Mirrors `handleUsage`'s recording side-effect for the failure path: the
+ * loop only reaches the success branch (and emits `usage`) when the
+ * provider returns a response, so without this handler a rejected call
+ * leaves nothing in the inspector — only a pino line saying "The AI
+ * provider rejected the request." The row's `messageId` is left null
+ * here and linked via one of two backfill paths, depending on how the
+ * turn unwinds:
+ *
+ *   - Multi-call turn where a later call also produces a real assistant
+ *     response: `handleMessageComplete` -> `backfillMessageIdOnLogs`
+ *     sweeps this row with the rest, same as a successful-call row.
+ *   - Pure provider-failure turn (no real assistant response): the
+ *     synthetic error-message branch in `conversation-agent-loop.ts`
+ *     persists a stand-in assistant message and calls
+ *     `backfillMessageIdOnLogs` itself, since `message_complete` is
+ *     never emitted on that path. Closing the orphan window inside the
+ *     same synchronous turn prevents a later turn's sweep from wrong-
+ *     attaching this row to an unrelated assistant message.
+ *
+ * Failures inside the recording itself are logged and swallowed — this
+ * mirrors `handleUsage`'s non-fatal stance so a DB hiccup never escalates
+ * a provider rejection into a dispatcher-level throw.
+ */
+function handleProviderError(
+  deps: EventHandlerDeps,
+  event: Extract<AgentEvent, { type: "provider_error" }>,
+): void {
+  try {
+    recordRequestLog(
+      deps.ctx.conversationId,
+      JSON.stringify(event.rawRequest),
+      JSON.stringify(buildProviderErrorResponsePayload(event.error)),
+      undefined,
+      event.actualProvider,
+    );
+  } catch (err) {
+    deps.rlog.warn(
+      { err },
+      "Failed to persist provider-error LLM request log (non-fatal)",
+    );
+  }
+}
+
 // ── Dispatcher ───────────────────────────────────────────────────────
 
 /** Routes an AgentEvent to the appropriate handler. */
@@ -1254,12 +1302,42 @@ export async function dispatchAgentEvent(
       case "error":
         handleError(state, deps, event);
         break;
+      case "provider_error":
+        handleProviderError(deps, event);
+        break;
       case "message_complete":
         await handleMessageComplete(state, deps, event);
         break;
       case "usage":
         handleUsage(state, deps, event);
         break;
+      case "agent_loop_exit":
+        // Stamp the exit reason onto the most-recent llm_request_logs
+        // row for this conversation. The final `usage` event of the run
+        // lands its row immediately before this event arrives (in the
+        // normal-dispatch path; the wake path handles ordering
+        // explicitly via `pendingExitReason`).
+        //
+        // Wrapped in try/catch so a DB hiccup here can't tear down the
+        // surrounding dispatch — the outer try/catch already swallows
+        // errors, but logging here gives the diagnosis hook a clear
+        // attribution to the exit handler specifically.
+        try {
+          setAgentLoopExitReasonOnLatestLog(
+            deps.ctx.conversationId,
+            event.reason,
+          );
+        } catch (err) {
+          log.warn(
+            {
+              err,
+              conversationId: deps.ctx.conversationId,
+              reason: event.reason,
+            },
+            "Failed to persist agent_loop_exit_reason (non-fatal)",
+          );
+        }
+        break;
     }
   } catch (err) {
     log.error(