@vellumai/assistant 0.6.3 → 0.6.5

package/src/daemon/approval-generators.ts

@@ -1,5 +1,7 @@
 import { loadConfig } from "../config/loader.js";
+import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { getProvider, listProviders } from "../providers/registry.js";
+import type { Provider } from "../providers/types.js";
 import {
   APPROVAL_COPY_MAX_TOKENS,
   APPROVAL_COPY_SYSTEM_PROMPT,
@@ -89,12 +91,15 @@ const VALID_DISPOSITIONS: ReadonlySet<string> = new Set([
 export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
   return async (context, options = {}) => {
     const config = loadConfig();
-    let provider;
+    let baseProvider: Provider;
     try {
-      provider = getProvider(config.services.inference.provider);
+      baseProvider = getProvider(config.llm.default.provider);
     } catch {
       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);
 
     const fallbackText =
       options.fallbackText?.trim() || getFallbackMessage(context);
@@ -114,6 +119,7 @@ export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
       {
         config: {
           max_tokens: options.maxTokens ?? APPROVAL_COPY_MAX_TOKENS,
+          callSite: "approvalCopy",
         },
         signal: AbortSignal.timeout(
           options.timeoutMs ?? APPROVAL_COPY_TIMEOUT_MS,
@@ -142,10 +148,12 @@ export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
 export function createApprovalConversationGenerator(): ApprovalConversationGenerator {
   return async (context) => {
     const config = loadConfig();
-    if (!listProviders().includes(config.services.inference.provider)) {
+    if (!listProviders().includes(config.llm.default.provider)) {
       throw new Error("No provider available for approval conversation");
     }
-    const provider = getProvider(config.services.inference.provider);
+    const provider = wrapWithCallSiteRouting(
+      getProvider(config.llm.default.provider),
+    );
 
     const pendingDescription = context.pendingApprovals
       .map((p) => `- Request ${p.requestId}: tool "${p.toolName}"`)
@@ -166,6 +174,7 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
       {
         config: {
           max_tokens: APPROVAL_CONVERSATION_MAX_TOKENS,
+          callSite: "approvalConversation",
         },
         signal: AbortSignal.timeout(APPROVAL_CONVERSATION_TIMEOUT_MS),
       },
@@ -215,3 +224,19 @@ 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/assistant-attachments.ts

@@ -8,6 +8,7 @@
 import { readFileSync, statSync } from "node:fs";
 import { basename } from "node:path";
 
+import { isPlaceholderSentinelText } from "../providers/anthropic/client.js";
 import {
   hostPolicy,
   sandboxPolicy,
@@ -692,19 +693,29 @@ export function cleanAssistantContent(content: readonly unknown[]): {
   const directives: DirectiveRequest[] = [];
   const warnings: string[] = [];
 
-  const cleanedContent = content.map((block) => {
-    const b = block as Record<string, unknown>;
-    if (b.type !== "text") return block;
-    const text = b.text as string;
-    // Only run the directive parser when the text actually contains a
-    // potential tag. This avoids unintentional whitespace normalisation
-    // (parseDirectives trims and collapses blank lines) on plain messages.
-    if (!text.includes("<vellum-attachment")) return block;
-    const result = parseDirectives(text);
-    directives.push(...result.directiveRequests);
-    warnings.push(...result.parseWarnings);
-    return { ...b, text: result.cleanText };
-  });
+  const cleanedContent = content
+    .filter((block) => {
+      // Drop placeholder sentinel text blocks. These are injected by the
+      // Anthropic provider to preserve role alternation in outbound requests
+      // and must never be persisted or rendered to users.
+      const b = block as Record<string, unknown>;
+      if (b.type !== "text") return true;
+      const text = b.text;
+      return typeof text !== "string" || !isPlaceholderSentinelText(text);
+    })
+    .map((block) => {
+      const b = block as Record<string, unknown>;
+      if (b.type !== "text") return block;
+      const text = b.text as string;
+      // Only run the directive parser when the text actually contains a
+      // potential tag. This avoids unintentional whitespace normalisation
+      // (parseDirectives trims and collapses blank lines) on plain messages.
+      if (!text.includes("<vellum-attachment")) return block;
+      const result = parseDirectives(text);
+      directives.push(...result.directiveRequests);
+      warnings.push(...result.parseWarnings);
+      return { ...b, text: result.cleanText };
+    });
 
   return { cleanedContent, directives, warnings };
 }

package/src/daemon/classifier.ts

@@ -28,7 +28,7 @@ export async function classifyInteraction(
     return "text_qa";
   }
 
-  const provider = await getConfiguredProvider();
+  const provider = await getConfiguredProvider("interactionClassifier");
   if (!provider) {
     log.warn(
       "No configured provider available, falling back to heuristic classification",
@@ -65,7 +65,7 @@ export async function classifyInteraction(
         "You are a classifier. Determine whether the user's request requires computer use (controlling the GUI — clicking, scrolling, typing into app windows, navigating between apps) or can be handled with local tools (answering questions, running terminal commands, creating/editing/reading files, web searches, writing code). GUI tasks → computer_use. Everything else → text_qa.",
         {
           config: {
-            modelIntent: "latency-optimized",
+            callSite: "interactionClassifier",
             max_tokens: 128,
             tool_choice: {
               type: "tool" as const,

package/src/daemon/config-watcher.ts

@@ -10,11 +10,12 @@ import {
   readdirSync,
   watch,
 } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 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 { clearCache as clearTrustCache } from "../permissions/trust-store.js";
 import { initializeProviders } from "../providers/registry.js";
@@ -30,6 +31,7 @@ import { getLogger } from "../util/logger.js";
 import {
   AVATAR_IMAGE_FILENAME,
   getAvatarDir,
+  getProtectedDir,
   getSignalsDir,
   getSoundsDir,
   getWorkspaceDir,
@@ -38,6 +40,17 @@ import {
 
 const log = getLogger("config-watcher");
 
+/**
+ * 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
+ * watched directory) are logged instead of crashing the process.
+ */
+function attachWatcherErrorHandler(watcher: FSWatcher, dir: string): void {
+  watcher.on("error", (err) => {
+    log.warn({ err, dir }, "FSWatcher error (non-fatal, continuing)");
+  });
+}
+
 export class ConfigWatcher {
   private watchers: FSWatcher[] = [];
   private debounceTimers = new DebouncerMap({
@@ -94,6 +107,7 @@ export class ConfigWatcher {
    * Returns true if config actually changed.
    */
   async refreshConfigFromSources(): Promise<boolean> {
+    const prevCleanup = safeGetCleanupConfig();
     invalidateConfigCache();
     const config = getConfig();
     const fingerprint = this.configFingerprint(config);
@@ -102,6 +116,13 @@ export class ConfigWatcher {
     }
     clearTrustCache();
     clearEmbeddingBackendCache();
+    // 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).
+    const nextCleanup = config.memory?.cleanup;
+    if (cleanupSettingsChanged(prevCleanup, nextCleanup)) {
+      resetCleanupScheduleThrottle();
+    }
     const isFirstInit = this.lastFingerprint === "";
     await initializeProviders(config);
     this.lastFingerprint = fingerprint;
@@ -151,8 +172,6 @@ export class ConfigWatcher {
         onConversationEvict();
         onIdentityChanged?.();
       },
-      "USER.md": () => onConversationEvict(),
-      "UPDATES.md": () => onConversationEvict(),
     };
 
     const watchDir = (
@@ -170,6 +189,7 @@ export class ConfigWatcher {
             handlers[file]();
           });
         });
+        attachWatcherErrorHandler(watcher, dir);
         this.watchers.push(watcher);
         log.info({ dir }, `Watching ${label}`);
       } catch (err) {
@@ -195,6 +215,7 @@ export class ConfigWatcher {
 
     this.startFeatureFlagsWatcher(onFeatureFlagsChanged);
     this.startSignalsWatcher();
+    this.startUsersWatcher(onConversationEvict);
     this.startSkillsWatchers(onConversationEvict);
   }
 
@@ -227,6 +248,7 @@ export class ConfigWatcher {
           onSoundsConfigChanged();
         });
       });
+      attachWatcherErrorHandler(watcher, soundsDir);
       this.watchers.push(watcher);
       log.info({ dir: soundsDir }, "Watching sounds directory for changes");
     } catch (err) {
@@ -237,6 +259,40 @@ export class ConfigWatcher {
     }
   }
 
+  private startUsersWatcher(onConversationEvict: () => void): void {
+    const usersDir = join(getWorkspaceDir(), "users");
+    try {
+      if (!existsSync(usersDir)) {
+        mkdirSync(usersDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(usersDir, (_eventType, filename) => {
+        if (!filename) return;
+        const file = String(filename);
+        if (!file.endsWith(".md")) return;
+        this.debounceTimers.schedule(`file:users/${file}`, () => {
+          log.info({ file }, "Users persona file changed, reloading");
+          onConversationEvict();
+        });
+      });
+      attachWatcherErrorHandler(watcher, usersDir);
+      this.watchers.push(watcher);
+      log.info(
+        { dir: usersDir },
+        "Watching users directory for persona changes",
+      );
+    } catch (err) {
+      log.warn(
+        { err, dir: usersDir },
+        "Failed to watch users directory. Persona file changes will require a restart.",
+      );
+    }
+  }
+
   private startAvatarWatcher(onAvatarChanged: () => void): void {
     const avatarDir = getAvatarDir();
     try {
@@ -259,6 +315,7 @@ export class ConfigWatcher {
           onAvatarChanged();
         });
       });
+      attachWatcherErrorHandler(watcher, avatarDir);
       this.watchers.push(watcher);
       log.info({ dir: avatarDir }, "Watching avatar directory for changes");
     } catch (err) {
@@ -270,9 +327,7 @@ export class ConfigWatcher {
   }
 
   private startFeatureFlagsWatcher(onFeatureFlagsChanged?: () => void): void {
-    const protectedDir = process.env.GATEWAY_SECURITY_DIR
-      ? process.env.GATEWAY_SECURITY_DIR
-      : join(homedir(), ".vellum", "protected");
+    const protectedDir = process.env.GATEWAY_SECURITY_DIR || getProtectedDir();
 
     try {
       if (!existsSync(protectedDir)) {
@@ -305,6 +360,7 @@ export class ConfigWatcher {
           500,
         );
       });
+      attachWatcherErrorHandler(watcher, protectedDir);
       this.watchers.push(watcher);
       log.info(
         { dir: protectedDir },
@@ -367,6 +423,7 @@ export class ConfigWatcher {
           }
         }
       });
+      attachWatcherErrorHandler(watcher, signalsDir);
       this.watchers.push(watcher);
       log.info({ dir: signalsDir }, "Watching signals directory");
     } catch (err) {
@@ -396,6 +453,7 @@ export class ConfigWatcher {
           scheduleSkillsReload(filename ? String(filename) : "(unknown)");
         },
       );
+      attachWatcherErrorHandler(recursiveWatcher, skillsDir);
       this.watchers.push(recursiveWatcher);
       log.info({ dir: skillsDir }, "Watching skills directory recursively");
       return;
@@ -416,6 +474,7 @@ export class ConfigWatcher {
         const watcher = watch(dirPath, (_eventType, filename) => {
           onChange(filename ? String(filename) : "(unknown)");
         });
+        attachWatcherErrorHandler(watcher, dirPath);
         this.watchers.push(watcher);
         return watcher;
       } catch (err) {
@@ -481,3 +540,37 @@ export class ConfigWatcher {
     );
   }
 }
+
+/**
+ * Snapshot the current cleanup config so we can compare it against the
+ * post-reload value. Tolerant of config-load failures — if the config can't
+ * be read (e.g. first-load), returns undefined so the comparison below
+ * treats it as "no previous value".
+ */
+function safeGetCleanupConfig(): MemoryCleanupConfig | undefined {
+  try {
+    return getConfig().memory?.cleanup;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Return true if any cleanup field the user can change via the UI differs
+ * between the previous and next config snapshots. Used to decide whether to
+ * reset the cleanup-scheduler throttle after a config reload so retention
+ * changes take effect immediately instead of waiting up to 6 hours.
+ *
+ * Exported for unit testing.
+ */
+export function cleanupSettingsChanged(
+  prev: MemoryCleanupConfig | undefined,
+  next: MemoryCleanupConfig | undefined,
+): boolean {
+  if (!prev || !next) return false;
+  return (
+    prev.llmRequestLogRetentionMs !== next.llmRequestLogRetentionMs ||
+    prev.conversationRetentionDays !== next.conversationRetentionDays ||
+    prev.enabled !== next.enabled
+  );
+}

package/src/daemon/context-overflow-reducer.ts

@@ -279,7 +279,10 @@ function applyMediaStubbing(
       providerName: config.providerName,
     });
     const adjustedNonMediaTokens = nonMediaTokens + estimatedStubTokens;
-    const mediaTokenBudget = Math.max(0, config.targetTokens - adjustedNonMediaTokens);
+    const mediaTokenBudget = Math.max(
+      0,
+      config.targetTokens - adjustedNonMediaTokens,
+    );
 
     const stripped = stripMediaPayloadsForRetry(messages, {
       mediaTokenBudget,

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

@@ -13,6 +13,8 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import { recordEstimate } from "../context/estimator-calibration.js";
+import { getCalibrationProviderKey } from "../context/token-estimator.js";
 import {
   addMessage,
   getConversation,
@@ -26,7 +28,13 @@ import {
   recordRequestLog,
 } from "../memory/llm-request-log-store.js";
 import { backfillMemoryRecallLogMessageId } from "../memory/memory-recall-log-store.js";
+import { getThreadTs } from "../memory/slack-thread-store.js";
+import {
+  type SlackMessageMetadata,
+  writeSlackMetadata,
+} from "../messaging/providers/slack/message-metadata.js";
 import type { ContentBlock, ImageContent } from "../providers/types.js";
+import { isContextOverflowError } from "../providers/types.js";
 import { ProviderError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
@@ -64,6 +72,8 @@ export interface EventHandlerState {
   exchangeCacheCreationInputTokens: number;
   exchangeCacheReadInputTokens: number;
   exchangeOutputTokens: number;
+  /** Input tokens from the most recent LLM API call (overwritten, not accumulated). */
+  lastCallInputTokens: number;
   /** Number of actual LLM API calls within this exchange. */
   exchangeLlmCallCount: number;
   readonly exchangeRawResponses: unknown[];
@@ -71,8 +81,14 @@ export interface EventHandlerState {
   orderingErrorDetected: boolean;
   deferredOrderingError: string | null;
   contextTooLargeDetected: boolean;
-  /** The raw error message from the provider when context_too_large is detected. */
-  contextTooLargeErrorMessage: string | null;
+  /**
+   * The provider error object when context_too_large is detected, preserved
+   * so `parseActualTokensFromError` can prefer the typed
+   * `ContextOverflowError` fields over the string-regex fallback. The
+   * message is always reachable via `.message` on this object — no separate
+   * field is needed.
+   */
+  contextTooLargeError: unknown;
   providerErrorUserMessage: string | null;
   lastAssistantMessageId: string | undefined;
   readonly pendingToolResults: Map<string, PendingToolResult>;
@@ -135,13 +151,14 @@ export function createEventHandlerState(): EventHandlerState {
     exchangeCacheCreationInputTokens: 0,
     exchangeCacheReadInputTokens: 0,
     exchangeOutputTokens: 0,
+    lastCallInputTokens: 0,
     exchangeLlmCallCount: 0,
     exchangeRawResponses: [],
     model: "",
     orderingErrorDetected: false,
     deferredOrderingError: null,
     contextTooLargeDetected: false,
-    contextTooLargeErrorMessage: null,
+    contextTooLargeError: null,
     providerErrorUserMessage: null,
     lastAssistantMessageId: undefined,
     pendingToolResults: new Map(),
@@ -201,12 +218,6 @@ const TOOL_FRIENDLY_NAMES: Record<string, string> = {
   file_read: "file read",
   file_write: "file write",
   file_edit: "file edit",
-  browser_navigate: "browser",
-  browser_click: "browser",
-  browser_type: "browser",
-  browser_screenshot: "browser",
-  browser_scroll: "browser",
-  browser_wait: "browser",
   app_create: "app",
   app_refresh: "app refresh",
   skill_load: "skill",
@@ -590,6 +601,7 @@ function annotatePersistedAssistantMessage(
         data: surface.data,
         actions: surface.actions,
         display: surface.display,
+        ...(surface.persistent ? { persistent: true } : {}),
       } as unknown as ContentBlock);
     }
     modified = true;
@@ -612,16 +624,20 @@ export function handleError(
   if (isProviderOrderingError(event.error.message)) {
     state.orderingErrorDetected = true;
     state.deferredOrderingError = event.error.message;
+  } else if (isContextOverflowError(event.error)) {
+    // Typed path — the provider client already classified this as overflow.
+    state.contextTooLargeDetected = true;
+    state.contextTooLargeError = event.error;
   } else if (isContextTooLarge(event.error.message)) {
     state.contextTooLargeDetected = true;
-    state.contextTooLargeErrorMessage = event.error.message;
+    state.contextTooLargeError = event.error;
   } else {
     const classified = classifyConversationError(event.error, {
       phase: "agent_loop",
     });
     if (classified.code === "CONTEXT_TOO_LARGE") {
       state.contextTooLargeDetected = true;
-      state.contextTooLargeErrorMessage = event.error.message;
+      state.contextTooLargeError = event.error;
     } else if (
       classified.code === "PROVIDER_ORDERING" ||
       classified.code === "PROVIDER_WEB_SEARCH"
@@ -759,10 +775,11 @@ export async function handleMessageComplete(
       data: surface.data,
       actions: surface.actions,
       display: surface.display,
+      ...(surface.persistent ? { persistent: true } : {}),
     } as unknown as ContentBlock);
   }
 
-  const assistantChannelMetadata = {
+  const assistantChannelMetadata: Record<string, unknown> = {
     ...provenanceFromTrustContext(deps.ctx.trustContext),
     userMessageChannel: deps.turnChannelContext.userMessageChannel,
     assistantMessageChannel: deps.turnChannelContext.assistantMessageChannel,
@@ -771,6 +788,34 @@ export async function handleMessageComplete(
       deps.turnInterfaceContext.assistantMessageInterface,
     sentAt: state.turnStartedAt,
   };
+
+  // When the assistant is replying through Slack, stamp a `slackMeta`
+  // sub-object so the transcript-rendering / thread-aware-context lookup
+  // can identify this row's thread without joining tables.
+  // Persistence happens BEFORE the Slack adapter sends the message, so
+  // Slack's authoritative `ts` (-> `channelTs`) is not yet known and is
+  // intentionally omitted here. The post-send reconciliation step in
+  // `deliverReplyViaCallback` writes `channelTs` back into this row once
+  // the gateway returns the Slack-assigned ts, restoring a fully-formed
+  // metadata envelope before any subsequent turn reads the row.
+  if (deps.turnChannelContext.assistantMessageChannel === "slack") {
+    const channelId = deps.ctx.trustContext?.requesterChatId;
+    if (channelId) {
+      const threadTs = getThreadTs(deps.ctx.conversationId);
+      const partialSlackMeta: Partial<SlackMessageMetadata> = {
+        source: "slack",
+        eventKind: "message",
+        channelId,
+        ...(threadTs ? { threadTs } : {}),
+      };
+      assistantChannelMetadata.slackMeta = writeSlackMetadata(
+        // `channelTs` is filled in by the post-send reconciliation step in
+        // `deliverReplyViaCallback`; cast through the Partial to satisfy
+        // the writer's type at this pre-send boundary.
+        partialSlackMeta as SlackMessageMetadata,
+      );
+    }
+  }
   const assistantMsg = await addMessage(
     deps.ctx.conversationId,
     "assistant",
@@ -831,10 +876,38 @@ export function handleUsage(
   state.exchangeProviderName = providerName;
   state.exchangeLlmCallCount += 1;
   state.exchangeInputTokens += event.inputTokens;
+  state.lastCallInputTokens = event.inputTokens;
   state.exchangeCacheCreationInputTokens += event.cacheCreationInputTokens ?? 0;
   state.exchangeCacheReadInputTokens += event.cacheReadInputTokens ?? 0;
   state.exchangeOutputTokens += event.outputTokens;
   state.model = event.model;
+
+  // Feed the self-calibration loop: compare the pre-send estimate to the
+  // provider's ground-truth inputTokens. `recordEstimate` silently ignores
+  // samples below its magnitude threshold or outside its outlier bounds,
+  // so it's safe to call unconditionally.
+  //
+  // The calibration key must match what `estimatePromptTokens` callers look
+  // up — use the canonical provider key (`tokenEstimationProvider ?? name`),
+  // falling back to the response's `actualProvider` only when neither hint
+  // is set on the provider object (shouldn't happen, but cheap). Using
+  // `event.actualProvider` as the primary key would scatter data across
+  // mismatched keys for wrapper providers like OpenRouter.
+  const calibrationProviderKey =
+    getCalibrationProviderKey(deps.ctx.provider) ||
+    (event.actualProvider ?? "");
+  if (
+    calibrationProviderKey.length > 0 &&
+    event.estimatedInputTokens !== undefined &&
+    event.estimatedInputTokens > 0
+  ) {
+    recordEstimate(
+      calibrationProviderKey,
+      event.model,
+      event.estimatedInputTokens,
+      event.inputTokens,
+    );
+  }
   if (event.rawResponse !== undefined) {
     state.exchangeRawResponses.push(event.rawResponse);
   }