@vellumai/assistant 0.8.1 → 0.8.3

package/src/daemon/conversation-process.ts

@@ -31,8 +31,12 @@ import { extractPreferences } from "../notifications/preference-extractor.js";
 import { createPreference } from "../notifications/preferences-store.js";
 import type { Message } from "../providers/types.js";
 import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
-import { persistQueuedMessageBody } from "./conversation-messaging.js";
+import {
+  persistQueuedMessageBody,
+  serializePersistedUserMessageContent,
+} from "./conversation-messaging.js";
 import type {
   MessageQueue,
   QueuedMessage,
@@ -513,11 +517,11 @@ async function drainSingleMessage(
       // When displayContent is provided (e.g. original text before recording
       // intent stripping), persist that to DB so users see the full message.
       // The in-memory userMessage (sent to the LLM) still uses the stripped content.
-      const contentToPersist = next.displayContent
-        ? JSON.stringify(
-            createUserMessage(next.displayContent, next.attachments).content,
-          )
-        : JSON.stringify(cleanUserMsg.content);
+      const contentToPersist = serializePersistedUserMessageContent(
+        next.content,
+        next.attachments,
+        next.displayContent,
+      );
       await addMessage(
         conversation.conversationId,
         "user",
@@ -570,6 +574,7 @@ async function drainSingleMessage(
         type: "message_complete",
         conversationId: conversation.conversationId,
       });
+      publishConversationMessagesChanged(conversation.conversationId);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -602,6 +607,7 @@ async function drainSingleMessage(
 
   // /compact — force context compaction, persist exchange, continue draining.
   if (slashResult.kind === "compact") {
+    let persistedCompactMessage = false;
     try {
       const drainProvenance = provenanceFromTrustContext(
         conversation.trustContext,
@@ -627,9 +633,14 @@ async function drainSingleMessage(
       await addMessage(
         conversation.conversationId,
         "user",
-        JSON.stringify(cleanUserMsg.content),
+        serializePersistedUserMessageContent(
+          next.content,
+          next.attachments,
+          next.displayContent,
+        ),
         drainChannelMeta,
       );
+      persistedCompactMessage = true;
       conversation.messages.push(cleanUserMsg);
 
       conversation.emitActivityState(
@@ -666,7 +677,11 @@ async function drainSingleMessage(
         type: "message_complete",
         conversationId: conversation.conversationId,
       });
+      publishConversationMessagesChanged(conversation.conversationId);
     } catch (err) {
+      if (persistedCompactMessage) {
+        publishConversationMessagesChanged(conversation.conversationId);
+      }
       const message = err instanceof Error ? err.message : String(err);
       log.error(
         {
@@ -762,6 +777,7 @@ async function drainSingleMessage(
     requestId: next.requestId,
     clientMessageId: next.clientMessageId,
   });
+  publishConversationMessagesChanged(conversation.conversationId);
 
   // Set the active surface for the dequeued message so runAgentLoop can inject context
   conversation.currentActiveSurfaceId = next.activeSurfaceId;
@@ -1087,6 +1103,7 @@ async function drainBatch(
       requestId: qm.requestId,
       clientMessageId: qm.clientMessageId,
     });
+    publishConversationMessagesChanged(conversation.conversationId);
 
     // Persist succeeded. Update last-successful markers so a later tail
     // failure won't overwrite them.
@@ -1306,7 +1323,11 @@ export async function processMessage(
       const persisted = await addMessage(
         conversation.conversationId,
         "user",
-        JSON.stringify(cleanUserMsg.content),
+        serializePersistedUserMessageContent(
+          content,
+          attachments,
+          displayContent,
+        ),
         routerChannelMeta,
       );
       conversation.messages.push(llmUserMsg);
@@ -1391,9 +1412,11 @@ export async function processMessage(
     // When displayContent is provided (e.g. original text before recording
     // intent stripping), persist that to DB so users see the full message.
     // The in-memory userMessage (sent to the LLM) still uses the stripped content.
-    const contentToPersist = displayContent
-      ? JSON.stringify(createUserMessage(displayContent, attachments).content)
-      : JSON.stringify(cleanUserMsg.content);
+    const contentToPersist = serializePersistedUserMessageContent(
+      content,
+      attachments,
+      displayContent,
+    );
     const persisted = await addMessage(
       conversation.conversationId,
       "user",
@@ -1446,12 +1469,14 @@ export async function processMessage(
       type: "message_complete",
       conversationId: conversation.conversationId,
     });
+    publishConversationMessagesChanged(conversation.conversationId);
     return persisted.id;
   }
 
   // /compact — force context compaction, persist exchange, return message ID.
   if (slashResult.kind === "compact") {
     conversation.processing = true;
+    let persistedCompactMessage = false;
     try {
       const pmTurnCtx = conversation.getTurnChannelContext();
       const pmInterfaceCtx = conversation.getTurnInterfaceContext();
@@ -1478,9 +1503,14 @@ export async function processMessage(
       const persisted = await addMessage(
         conversation.conversationId,
         "user",
-        JSON.stringify(cleanUserMsg.content),
+        serializePersistedUserMessageContent(
+          content,
+          attachments,
+          displayContent,
+        ),
         pmChannelMeta,
       );
+      persistedCompactMessage = true;
       conversation.messages.push(cleanUserMsg);
 
       conversation.emitActivityState(
@@ -1517,7 +1547,13 @@ export async function processMessage(
         type: "message_complete",
         conversationId: conversation.conversationId,
       });
+      publishConversationMessagesChanged(conversation.conversationId);
       return persisted.id;
+    } catch (err) {
+      if (persistedCompactMessage) {
+        publishConversationMessagesChanged(conversation.conversationId);
+      }
+      throw err;
     } finally {
       conversation.processing = false;
       await drainQueue(conversation);
@@ -1557,6 +1593,7 @@ export async function processMessage(
       undefined,
       displayContent,
     );
+    publishConversationMessagesChanged(conversation.conversationId);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     onEvent({

package/src/daemon/conversation-runtime-assembly.ts

@@ -1182,12 +1182,23 @@ function placeholderForBlockType(type: ContentBlock["type"]): string | null {
  */
 function rowToRenderable(row: SlackTranscriptInputRow): RenderableSlackMessage {
   let slackMeta: ReturnType<typeof readSlackMetadata> = null;
+  let provenanceTrustClass: TrustClass | undefined;
   if (row.metadata) {
     try {
-      const outer = JSON.parse(row.metadata) as { slackMeta?: unknown };
+      const outer = JSON.parse(row.metadata) as {
+        slackMeta?: unknown;
+        provenanceTrustClass?: unknown;
+      };
       if (typeof outer.slackMeta === "string") {
         slackMeta = readSlackMetadata(outer.slackMeta);
       }
+      if (
+        outer.provenanceTrustClass === "guardian" ||
+        outer.provenanceTrustClass === "trusted_contact" ||
+        outer.provenanceTrustClass === "unknown"
+      ) {
+        provenanceTrustClass = outer.provenanceTrustClass;
+      }
     } catch {
       // Malformed metadata — fall through to legacy/null treatment.
     }
@@ -1252,6 +1263,8 @@ function rowToRenderable(row: SlackTranscriptInputRow): RenderableSlackMessage {
     senderLabel,
     createdAt: row.createdAt,
     contentBlocks,
+    wrapContentForModel:
+      row.role === "user" && !isReaction && provenanceTrustClass !== "guardian",
   };
 }
 
@@ -1639,6 +1652,7 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<interface_turn_context>", // backward-compat: strip legacy separate interface blocks
   // NOTE: <turn_context> is intentionally NOT stripped — unified turn context
   // blocks persist in history so the assistant retains temporal/actor grounding.
+  "<background_turn>",
   "<memory_context __injected>",
   "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
   // The static `memory-v2-static` block (opens `<memory>\n…`) IS stripped
@@ -1953,6 +1967,13 @@ export interface RuntimeInjectionOptions {
   nowScratchpad?: string | null;
   subagentStatusBlock?: string | null;
   isNonInteractive?: boolean;
+  /**
+   * True when the active conversation's type is "background" or "scheduled".
+   * Forwarded to {@link TurnInjectionInputs.isBackgroundConversation} so the
+   * `background-turn` injector can wrap the tail user message with the
+   * configured reminder.
+   */
+  isBackgroundConversation?: boolean;
   transportHints?: string[] | null;
   slackRuntimeContextNotice?: string | null;
   /**
@@ -1989,6 +2010,7 @@ export interface RuntimeInjectionOptions {
    * `undefined` when the inbound is a top-level (non-thread) post.
    */
   slackActiveThreadFocusBlock?: string | null;
+  activeDocuments?: TurnInjectionInputs["activeDocuments"];
   mode?: InjectionMode;
   /**
    * Per-turn {@link TurnContext} forwarded to plugin-registered
@@ -2042,6 +2064,8 @@ function buildTurnInjectionInputs(
     voiceCallControlPrompt: options.voiceCallControlPrompt,
     transportHints: options.transportHints,
     isNonInteractive: options.isNonInteractive,
+    isBackgroundConversation: options.isBackgroundConversation,
+    activeDocuments: options.activeDocuments,
   };
 }
 

package/src/daemon/conversation-slash.ts

@@ -8,8 +8,8 @@ import {
   saveRawConfig,
 } from "../config/loader.js";
 import { getConversationOverrideProfile } from "../memory/conversation-crud.js";
-import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
 import { getConfiguredProviders } from "../providers/provider-availability.js";
+import { getVisibleProviderCatalog } from "../providers/provider-catalog-visibility.js";
 
 export type SlashResolution =
   | { kind: "passthrough"; content: string }
@@ -132,7 +132,10 @@ function parseModelCommand(trimmed: string): ModelCommandParse | null {
 }
 
 function orderedProfileNames(
-  profiles: Record<string, { label?: string; description?: string; status?: "active" | "disabled" }>,
+  profiles: Record<
+    string,
+    { label?: string; description?: string; status?: "active" | "disabled" }
+  >,
   profileOrder: readonly string[] | undefined,
 ): string[] {
   const order = profileOrder ?? [];
@@ -177,8 +180,12 @@ async function resolveModelCommand(
       const isDisabled = profile.status === "disabled";
       const marker = isCurrent ? " **[current]**" : "";
       const disabled = isDisabled ? " *(disabled)*" : "";
-      const description = profile.description ? ` — ${profile.description}` : "";
-      lines.push(`  - \`${name}\` (${label})${marker}${disabled}${description}`);
+      const description = profile.description
+        ? ` — ${profile.description}`
+        : "";
+      lines.push(
+        `  - \`${name}\` (${label})${marker}${disabled}${description}`,
+      );
     }
     lines.push("\nSwitch with `/model <name>`.");
     return { kind: "unknown", message: lines.join("\n") };
@@ -240,7 +247,7 @@ async function resolveModelList(): Promise<SlashResolution> {
     id: provider,
     displayName: providerName,
     models,
-  } of PROVIDER_CATALOG) {
+  } of getVisibleProviderCatalog(config)) {
     const hasKey = configuredProviders.has(provider);
     const status = hasKey ? "✓" : "✗";
     lines.push(`**${providerName}** ${status}`);

package/src/daemon/conversation-store.ts

@@ -21,7 +21,9 @@ import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
 import { resolveDefaultProvider } from "../providers/connection-resolution.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
+import { listProviders } from "../providers/registry.js";
 import { getSubagentManager } from "../subagent/index.js";
+import { ProviderNotConfiguredError } from "../util/errors.js";
 import { getSandboxWorkingDir } from "../util/platform.js";
 import { Conversation } from "./conversation.js";
 import type { ConversationEvictor } from "./conversation-evictor.js";
@@ -226,12 +228,17 @@ export async function getOrCreateConversation(
       // Connection-aware default-provider resolution. Throws
       // `ConnectionResolutionError` when the default profile's
       // `provider_connection` is unset / unknown / mismatched (config
-      // bugs). Returns null on soft credential failures (handled below
-      // as "default provider not registered").
+      // bugs). Returns null on soft credential failures (missing
+      // credential, platform auth unavailable).
       const baseProvider = await resolveDefaultProvider(config);
       if (!baseProvider) {
-        throw new Error(
-          `Conversation: default provider '${resolveCallSiteConfig("mainAgent", config.llm).provider}' is not registered`,
+        const resolved = resolveCallSiteConfig("mainAgent", config.llm);
+        throw new ProviderNotConfiguredError(
+          resolved.provider,
+          listProviders(),
+          {
+            connectionName: resolved.provider_connection,
+          },
         );
       }
       // Per-call `callSite` routing layered on top, with connection-awareness

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

@@ -13,6 +13,7 @@ import {
 } from "../channels/types.js";
 import { isHttpAuthDisabled } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
+import { getConfig } from "../config/loader.js";
 import { getBindingByConversation } from "../memory/external-conversation-store.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
@@ -392,7 +393,8 @@ const CROSS_CLIENT_EXPOSED_CAPABILITIES = new Set<HostProxyCapability>([
   "host_file",
   "host_browser",
 ]);
-const CLIENT_CAPABILITY_TOOL_NAMES = new Set(["app_open"]);
+// Tools that require a connected client but no specific host proxy capability.
+const CLIENT_CAPABILITY_TOOL_NAMES = new Set(["app_open", "ask_question"]);
 const PLATFORM_TOOL_NAMES = new Set(["request_system_permission"]);
 
 /**
@@ -406,16 +408,34 @@ export const SUBAGENT_ONLY_TOOL_NAMES = new Set<string>([
 ]);
 
 /**
- * Determine whether a tool should be included in the LLM tool definitions
- * for the current turn based on conversation context. Tools not active for the
- * current context are omitted from the definitions sent to the provider,
- * reducing noise and preventing the model from attempting calls that would
- * fail.
+ * Determine whether a tool is part of the final exposed tool set for the
+ * current turn. This helper mirrors the filtering applied by
+ * `createResolveToolsCallback` — including the subagent allowlist,
+ * `toolsDisabledDepth`, and disk-pressure cleanup restrictions.
  */
 export function isToolActiveForContext(
   name: string,
   ctx: SkillProjectionContext,
 ): boolean {
+  // When the conversation is acting as a subagent, the parent orchestrator
+  // restricts the tool list. A tool that isn't on the allowlist is not
+  // available for this turn, so short-circuit before any capability checks.
+  if (ctx.subagentAllowedTools && !ctx.subagentAllowedTools.has(name)) {
+    return false;
+  }
+  // `createResolveToolsCallback` returns an empty tool list when tools are
+  // disabled (e.g. pointer-generation turns) and restricts to cleanup-safe
+  // tools under disk pressure. Mirror both here so this helper reports the
+  // same final tool set the LLM receives.
+  if (ctx.toolsDisabledDepth > 0) {
+    return false;
+  }
+  if (
+    ctx.diskPressureCleanupModeActive === true &&
+    !isDiskPressureCleanupToolName(name)
+  ) {
+    return false;
+  }
   if (UI_SURFACE_TOOL_NAMES.has(name)) {
     return ctx.channelCapabilities?.supportsDynamicUi ?? !ctx.hasNoClient;
   }
@@ -463,6 +483,14 @@ export function isToolActiveForContext(
     return !ctx.hasNoClient;
   }
   if (CLIENT_CAPABILITY_TOOL_NAMES.has(name)) {
+    if (
+      name === "ask_question" &&
+      ctx.channelCapabilities?.clientOS === "macos"
+    ) {
+      // macOS has no UI handler for question_request yet; hiding the tool
+      // avoids a 5-minute prompter timeout when the LLM would otherwise call it.
+      return false;
+    }
     return !ctx.hasNoClient;
   }
   if (PLATFORM_TOOL_NAMES.has(name)) {
@@ -544,7 +572,10 @@ export function createResolveToolsCallback(
     const scopedMcpDefs = ctx.subagentAllowedTools
       ? currentMcpDefs.filter((d) => ctx.subagentAllowedTools!.has(d.name))
       : currentMcpDefs;
-    const allBaseDefs = [...scopedCoreDefs, ...scopedMcpDefs];
+    const excluded = new Set(getConfig().tools.exclude);
+    const allBaseDefs = [...scopedCoreDefs, ...scopedMcpDefs].filter(
+      (d) => !excluded.has(d.name),
+    );
 
     const effectivePreactivated = [
       ...DEFAULT_PREACTIVATED_SKILL_IDS,
@@ -561,6 +592,7 @@ export function createResolveToolsCallback(
       if (ctx.subagentAllowedTools && !ctx.subagentAllowedTools.has(name)) {
         continue;
       }
+      if (excluded.has(name)) continue;
       turnAllowed.add(name);
     }
     if (ctx.diskPressureCleanupModeActive === true) {

package/src/daemon/conversation.ts

@@ -54,8 +54,8 @@ import {
   getConversationOriginChannel,
   getConversationOverrideProfileFromRow,
 } from "../memory/conversation-crud.js";
-import { isBackgroundConversationType } from "../memory/conversation-types.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
+import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { UserDecision } from "../permissions/types.js";
@@ -118,6 +118,7 @@ import {
   buildToolDefinitions,
   createResolveToolsCallback,
   createToolExecutor,
+  resolveTrustClass,
 } from "./conversation-tool-setup.js";
 import { refreshWorkspaceTopLevelContextIfNeeded as refreshWorkspaceImpl } from "./conversation-workspace.js";
 import { canonicalizeTimeZone } from "./date-context.js";
@@ -180,6 +181,17 @@ export class Conversation {
   /** @internal */ contextWindowManager: ContextWindowManager;
   /** @internal */ contextCompactedMessageCount = 0;
   /** @internal */ contextCompactedAt: number | null = null;
+  /**
+   * Set true by `applyCompactionResult` when compaction strips runtime
+   * injections from the tail. The next agent loop turn reads this flag at
+   * entry, treats it as a `compactedThisTurn` trigger (re-injecting NOW.md,
+   * PKB, and the v2 essentials/threads/recent/buffer block), and clears it.
+   *
+   * Required because `/compact` runs outside the agent loop — without this
+   * signal, the next turn cannot tell that the static blocks were just
+   * stripped and never re-emits them.
+   */
+  /** @internal */ pendingPostCompactReinject = false;
   /**
    * Tracks consecutive compaction failures (summary LLM call threw). In-memory
    * only — resets to 0 on process restart, which is the intended "one free
@@ -225,6 +237,7 @@ export class Conversation {
   /** @internal */ currentTurnOverrideProfile?: string;
   /** @internal */ authContext?: AuthContext;
   /** @internal */ loadedHistoryTrustClass?: TrustClass;
+  /** @internal */ loadedHistoryPersonalMemoryAllowed?: boolean;
   /** @internal */ voiceCallControlPrompt?: string;
   /** @internal */ transportHints?: string[];
   /** @internal */ slackRuntimeContextNotice?: string;
@@ -475,9 +488,6 @@ export class Conversation {
                 channelPersona: persona.channelPersona,
                 userSlug: persona.userSlug,
                 onboardingContext: this.getOnboardingContext(),
-                isBackgroundConversation: isBackgroundConversationType(
-                  getConversation(this.conversationId)?.conversationType,
-                ),
               });
             })(),
       };
@@ -527,6 +537,10 @@ export class Conversation {
       systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
       config: initialContextWindowConfig,
       toolTokenBudget: this.agentLoop.getToolTokenBudget(),
+      conversationId: this.conversationId,
+      resolveTools: resolveTools
+        ? () => resolveTools(this.messages)
+        : undefined,
     });
   }
 
@@ -565,9 +579,6 @@ export class Conversation {
             channelPersona: persona.channelPersona,
             userSlug: persona.userSlug,
             onboardingContext: this.getOnboardingContext(),
-            isBackgroundConversation: isBackgroundConversationType(
-              getConversation(this.conversationId)?.conversationType,
-            ),
           });
         })();
     const tools = buildToolDefinitions();
@@ -647,7 +658,21 @@ export class Conversation {
 
   async ensureActorScopedHistory(): Promise<void> {
     const currentTrustClass = this.trustContext?.trustClass;
-    if (this.loadedHistoryTrustClass === currentTrustClass) return;
+    // `loadFromDb` gates personal-memory rehydration on `sourceChannel` too
+    // (via `shouldExposePersonalMemory`), so a same-trust-class reuse from a
+    // different channel (e.g. internal `vellum` → remote channel) must also
+    // trigger a reload. Otherwise stale personal-memory blocks can leak to
+    // an untrusted remote turn, or be hidden when they should be present.
+    const currentPersonalMemoryAllowed = shouldExposePersonalMemory({
+      sourceChannel: this.trustContext?.sourceChannel,
+      isTrustedActor: resolveTrustClass(this.trustContext) === "guardian",
+    });
+    if (
+      this.loadedHistoryTrustClass === currentTrustClass &&
+      this.loadedHistoryPersonalMemoryAllowed === currentPersonalMemoryAllowed
+    ) {
+      return;
+    }
     await this.loadFromDb();
   }
 

package/src/daemon/date-context.ts

@@ -326,6 +326,46 @@ function formatLocalDate(date: Date, timeZone: string): string {
   ).padStart(2, "0")}`;
 }
 
+const localTimestampFormatterCache = new Map<string, Intl.DateTimeFormat>();
+
+function getLocalTimestampFormatter(timeZone: string): Intl.DateTimeFormat {
+  let fmt = localTimestampFormatterCache.get(timeZone);
+  if (!fmt) {
+    fmt = new Intl.DateTimeFormat("en-CA", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23",
+    });
+    localTimestampFormatterCache.set(timeZone, fmt);
+  }
+  return fmt;
+}
+
+/**
+ * Format an epoch-millis instant as `YYYY-MM-DD HH:MM:SS` in the given
+ * IANA timezone. When `timeZone` is omitted or `"UTC"`, falls back to a
+ * pure-UTC `toISOString` slice so callers can opt in incrementally.
+ *
+ * The internal `Intl.DateTimeFormat` is memoized by `timeZone` because
+ * constructing it is ~1ms in V8 — material when rendering long transcripts.
+ */
+export function formatLocalTimestamp(ms: number, timeZone?: string): string {
+  if (!timeZone || timeZone === "UTC") {
+    return new Date(ms).toISOString().replace("T", " ").slice(0, 19);
+  }
+  const parts = getLocalTimestampFormatter(timeZone).formatToParts(
+    new Date(ms),
+  );
+  const v: Record<string, string> = {};
+  for (const p of parts) v[p.type] = p.value;
+  return `${v.year}-${v.month}-${v.day} ${v.hour}:${v.minute}:${v.second}`;
+}
+
 export function resolveTurnTimezoneContext(
   options: TemporalContextOptions = {},
 ): TurnTimezoneContext {