@vellumai/assistant 0.8.0 → 0.8.2

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

@@ -20,10 +20,11 @@
  * hasNoClient flag.
  *
  * Cross-client exception: tools whose capabilities are in
- * CROSS_CLIENT_EXPOSED_CAPABILITIES (host_bash, host_file) are allowed for
- * non-host-proxy interfaces (e.g. "web") when at least one capable client
- * is connected via the event hub. host_browser is excluded (chrome-extension
- * is its own executor; web turns have no CDP target model).
+ * CROSS_CLIENT_EXPOSED_CAPABILITIES (host_bash, host_file, host_browser)
+ * are allowed for non-host-proxy interactive interfaces ("web", "ios")
+ * when at least one capable client is connected via the event hub.
+ * chrome-extension is excluded as a security boundary, regardless of
+ * whether the capability is technically supported elsewhere.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -358,6 +359,184 @@ describe("isToolActiveForContext — cross-client exposure for host_file_*", ()
   });
 });
 
+describe("isToolActiveForContext — cross-client exposure for host_browser", () => {
+  // host_browser cross-client routing was shipped in PR #27489 (host-
+  // browser-via-macos-host-proxy); LLM-exposure for non-host-proxy
+  // transports is added by including "host_browser" in
+  // CROSS_CLIENT_EXPOSED_CAPABILITIES. Web and iOS turns can now drive a
+  // connected macOS or chrome-extension client via the event hub.
+  test("host_browser is exposed for web transport when a host_browser client is connected", () => {
+    mockClientCountByCapability.set("host_browser", 1);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("host_browser is exposed for ios transport when a host_browser client is connected", () => {
+    // INTERACTIVE_INTERFACES = {macos, ios, web}; ios goes through the same
+    // cross-client branch as web because supportsHostProxy("ios", *) is
+    // false. This pins the parity guarantee.
+    mockClientCountByCapability.set("host_browser", 1);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "ios" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("host_browser is NOT exposed for web when no host_browser client is connected", () => {
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_browser is NOT exposed for ios when no host_browser client is connected", () => {
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "ios" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_browser is NOT exposed when hasNoClient is true (no approval UI)", () => {
+    // hasNoClient gate: cross-client exception must not bypass this.
+    mockClientCountByCapability.set("host_browser", 1);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: true, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_browser for macos transport is unaffected by the cross-client exception", () => {
+    // macos natively supports host_browser via host proxy — the
+    // supportsHostProxy check passes, so the cross-client branch is never
+    // reached.
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "macos" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("host_browser for chrome-extension transport is unaffected by the cross-client exception", () => {
+    // chrome-extension natively supports host_browser via its own
+    // executor (supportsHostProxy("chrome-extension", "host_browser")
+    // returns true), so the cross-client branch is never reached. The
+    // hasNoClient gate is also bypassed for chrome-extension transports
+    // because the extension provides its own approval UI.
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: true, transportInterface: "chrome-extension" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("listClientsByCapability is queried with host_browser, not host_bash or host_file (per-capability invariant)", () => {
+    // Defense against any future regression that hardcodes a different
+    // capability in the cross-client check. Only host_browser-capable
+    // clients should satisfy host_browser exposure.
+    mockClientCountByCapability.set("host_bash", 1);
+    mockClientCountByCapability.set("host_file", 1);
+    mockClientCountByCapability.set("host_browser", 0);
+    expect(
+      isToolActiveForContext(
+        "host_browser",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+});
+
+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/__tests__/daemon-skill-host.test.ts

@@ -23,8 +23,9 @@ const loggerSpy = {
   warn: mock(() => {}),
   error: mock(() => {}),
 };
+const getLoggerSpy = mock((_name: string) => loggerSpy);
 mock.module("../../util/logger.js", () => ({
-  getLogger: () => loggerSpy,
+  getLogger: getLoggerSpy,
 }));
 
 mock.module("../../config/loader.js", () => ({
@@ -163,12 +164,13 @@ describe("createDaemonSkillHost", () => {
     expect(host.speakers).toBeDefined();
   });
 
-  test("logger.get returns an object with the four severity methods", () => {
+  test("logger.get prefixes the scope with the skillId", () => {
     const log = host.logger.get("test-scope");
     log.debug("d", { k: "v" });
     log.info("i");
     log.warn("w");
     log.error("e");
+    expect(getLoggerSpy).toHaveBeenCalledWith("meet-join:test-scope");
     expect(loggerSpy.debug).toHaveBeenCalled();
     expect(loggerSpy.info).toHaveBeenCalled();
     expect(loggerSpy.warn).toHaveBeenCalled();
@@ -255,8 +257,12 @@ describe("createDaemonSkillHost", () => {
     });
     expect(handle).toBeDefined();
     expect(registerSkillRouteSpy).toHaveBeenCalled();
-    host.registries.registerShutdownHook("test-hook", async () => {});
-    expect(registerShutdownHookSpy).toHaveBeenCalled();
+    const hook = async () => {};
+    host.registries.registerShutdownHook("test-hook", hook);
+    expect(registerShutdownHookSpy).toHaveBeenCalledWith(
+      "meet-join:test-hook",
+      hook,
+    );
   });
 
   test("speakers.createTracker yields a concrete tracker instance", () => {

package/src/daemon/approval-generators.ts

@@ -1,6 +1,8 @@
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { loadConfig } from "../config/loader.js";
-import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
-import { getProvider, listProviders } from "../providers/registry.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
@@ -79,15 +82,18 @@ const VALID_DISPOSITIONS: ReadonlySet<string> = new Set([
 export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
   return async (context, options = {}) => {
     const config = loadConfig();
-    let baseProvider: Provider;
-    try {
-      baseProvider = getProvider(config.llm.default.provider);
-    } catch {
-      return null;
-    }
+    // Connection-aware default-provider resolution. Throws
+    // `ConnectionResolutionError` on hard config errors (missing /
+    // unknown / mismatched connection). Returns null on soft credential
+    // failures (vault miss, transient auth) — we treat null as "no
+    // provider available" and skip generating copy.
+    const baseProvider: Provider | null = await resolveDefaultProvider(config);
+    if (!baseProvider) return null;
     // Wrap so per-call `callSite` can route to an alternative provider
     // transport when `llm.callSites.<id>.provider` overrides the default.
-    const provider = wrapWithCallSiteRouting(baseProvider);
+    // The `wrapWithCallSiteRouting` helper threads `config` through so the
+    // wrapper's per-call resolution is also connection-aware.
+    const provider = wrapWithCallSiteRouting(baseProvider, config);
 
     const fallbackText =
       options.fallbackText?.trim() || getFallbackMessage(context);
@@ -136,12 +142,18 @@ export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
 export function createApprovalConversationGenerator(): ApprovalConversationGenerator {
   return async (context) => {
     const config = loadConfig();
-    if (!listProviders().includes(config.llm.default.provider)) {
-      throw new Error("No provider available for approval conversation");
+    // Connection-aware default + per-call routing. `resolveDefaultProvider`
+    // throws `ConnectionResolutionError` on hard config errors (missing /
+    // unknown / mismatched connection) and returns null on soft credential
+    // failures (missing credential, platform auth unavailable).
+    const baseProvider = await resolveDefaultProvider(config);
+    if (!baseProvider) {
+      const resolved = resolveCallSiteConfig("mainAgent", config.llm);
+      throw new ProviderNotConfiguredError(resolved.provider, listProviders(), {
+        connectionName: resolved.provider_connection,
+      });
     }
-    const provider = wrapWithCallSiteRouting(
-      getProvider(config.llm.default.provider),
-    );
+    const provider = wrapWithCallSiteRouting(baseProvider, config);
 
     const pendingDescription = context.pendingApprovals
       .map((p) => `- Request ${p.requestId}: tool "${p.toolName}"`)
@@ -212,19 +224,3 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
     return result;
   };
 }
-
-/**
- * Wrap a base Provider so per-call `callSite` metadata can route the actual
- * transport to a different provider when `llm.callSites.<id>.provider`
- * differs from the default. Without this wrapper, only request metadata
- * reflects the callSite — the HTTP transport stays bound to the default.
- */
-function wrapWithCallSiteRouting(base: Provider): Provider {
-  return new CallSiteRoutingProvider(base, (name) => {
-    try {
-      return getProvider(name);
-    } catch {
-      return undefined;
-    }
-  });
-}

package/src/daemon/config-watcher.ts

@@ -4,6 +4,7 @@
  * for changes.
  */
 import {
+  type Dirent,
   existsSync,
   type FSWatcher,
   mkdirSync,
@@ -12,7 +13,7 @@ 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";
@@ -37,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
@@ -158,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,
@@ -165,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
@@ -220,7 +243,7 @@ export class ConfigWatcher {
 
     this.startSignalsWatcher();
     this.startUsersWatcher(onConversationEvict);
-    this.startSkillsWatchers(onConversationEvict);
+    this.startSkillsWatchers(onConversationEvict, onSkillsChanged);
   }
 
   stop(): void {
@@ -420,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?.();
       });
     };
 
@@ -476,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

@@ -118,6 +118,12 @@ export interface EventHandlerState {
   orderingErrorDetected: boolean;
   deferredOrderingError: string | null;
   contextTooLargeDetected: boolean;
+  /**
+   * Set when the provider rejects with an image-dimension error. The agent
+   * loop strips or downscales oversized image blocks from ctx.messages and
+   * retries once before surfacing an error to the user.
+   */
+  imageTooLargeDetected: boolean;
   /**
    * The provider error object when context_too_large is detected, preserved
    * so `parseActualTokensFromError` can prefer the typed
@@ -127,6 +133,11 @@ export interface EventHandlerState {
    */
   contextTooLargeError: unknown;
   providerErrorUserMessage: string | null;
+  /**
+   * First persisted assistant row in this run; history keeps this id when it
+   * merges tool-turn rows into one display bubble.
+   */
+  firstAssistantMessageId: string | undefined;
   lastAssistantMessageId: string | undefined;
   readonly pendingToolResults: Map<string, PendingToolResult>;
   readonly persistedToolUseIds: Set<string>;
@@ -220,8 +231,10 @@ export function createEventHandlerState(): EventHandlerState {
     orderingErrorDetected: false,
     deferredOrderingError: null,
     contextTooLargeDetected: false,
+    imageTooLargeDetected: false,
     contextTooLargeError: null,
     providerErrorUserMessage: null,
+    firstAssistantMessageId: undefined,
     lastAssistantMessageId: undefined,
     pendingToolResults: new Map(),
     persistedToolUseIds: new Set(),
@@ -245,6 +258,12 @@ export function createEventHandlerState(): EventHandlerState {
   };
 }
 
+export function getClientDisplayMessageId(
+  state: EventHandlerState,
+): string | undefined {
+  return state.firstAssistantMessageId ?? state.lastAssistantMessageId;
+}
+
 // ── Shared Helper ────────────────────────────────────────────────────
 
 // providerNameOverride should be supplied when the caller already knows the
@@ -781,6 +800,10 @@ function handleError(
     if (classified.code === "CONTEXT_TOO_LARGE") {
       state.contextTooLargeDetected = true;
       state.contextTooLargeError = event.error;
+    } else if (classified.code === "IMAGE_TOO_LARGE") {
+      // Trigger silent recovery: the agent loop will strip/downscale images
+      // in ctx.messages and retry once before surfacing an error.
+      state.imageTooLargeDetected = true;
     } else if (
       classified.code === "PROVIDER_ORDERING" ||
       classified.code === "PROVIDER_WEB_SEARCH"
@@ -1004,6 +1027,7 @@ export async function handleMessageComplete(
     DEFAULT_TIMEOUTS.persistence,
   )) as PersistAddResult;
   const assistantMsg = assistantPersistResult.message;
+  state.firstAssistantMessageId ??= assistantMsg.id;
   state.lastAssistantMessageId = assistantMsg.id;
 
   // Backfill message_id on all LLM request logs from this turn.