@vellumai/assistant 0.8.0 → 0.8.2

package/src/memory/conversation-queries.ts

@@ -1,5 +1,11 @@
 import { and, count, desc, eq, sql } from "drizzle-orm";
 
+import {
+  parseExternalContentEnvelope,
+  type UntrustedContentSource,
+  unwrapExternalContentForDisplay,
+  wrapUntrustedContent,
+} from "../security/untrusted-content.js";
 import { getLogger } from "../util/logger.js";
 import type { ConversationRow } from "./conversation-crud.js";
 import { parseConversation } from "./conversation-crud.js";
@@ -51,9 +57,18 @@ export function listConversations(
   ensureDisplayOrderMigration();
   ensureGroupMigration();
   const db = getDb();
+  // 'private' is excluded defensively: in-place snapshot restore swaps the
+  // SQLite file without running migrations in-process, so legacy private rows
+  // can briefly exist before migration cleanup. Hide them from foreground
+  // lists until the next migration pass deletes them.
+  //
+  // group_id is checked alongside conversationType so that conversations
+  // routed to system:background (e.g. heartbeat) via conversationMetadata
+  // but created with conversationType "standard" (vellum channel strategy)
+  // appear in the correct bucket.
   const typeCond = backgroundOnly
-    ? sql`${conversations.conversationType} IN ('background', 'scheduled') AND (${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`
-    : sql`${conversations.conversationType} NOT IN ('background', 'scheduled')`;
+    ? sql`(${conversations.conversationType} IN ('background', 'scheduled') OR group_id IN ('system:background', 'system:scheduled')) AND (${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`
+    : sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private') AND COALESCE(group_id, 'system:all') NOT IN ('system:background', 'system:scheduled')`;
   const where = includeArchived
     ? typeCond
     : sql`${typeCond} AND ${conversations.archivedAt} IS NULL`;
@@ -80,7 +95,7 @@ export function listPinnedConversations(): ConversationRow[] {
     .from(conversations)
     .where(
       and(
-        sql`${conversations.conversationType} NOT IN ('background', 'scheduled')`,
+        sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private')`,
         sql`is_pinned = 1`,
       ),
     )
@@ -147,10 +162,11 @@ export function listConversationsByTitlePrefix(
 }
 
 export function countConversations(backgroundOnly = false): number {
+  ensureGroupMigration();
   const db = getDb();
   const where = backgroundOnly
-    ? sql`${conversations.conversationType} IN ('background', 'scheduled') AND (${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`
-    : sql`${conversations.conversationType} NOT IN ('background', 'scheduled')`;
+    ? sql`(${conversations.conversationType} IN ('background', 'scheduled') OR group_id IN ('system:background', 'system:scheduled')) AND (${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`
+    : sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private') AND COALESCE(group_id, 'system:all') NOT IN ('system:background', 'system:scheduled')`;
   const [{ total }] = db
     .select({ total: count() })
     .from(conversations)
@@ -229,6 +245,7 @@ export function searchConversations(
 ): ConversationSearchResult[] {
   if (!query.trim()) return [];
 
+  ensureGroupMigration();
   const db = getDb();
   const limit = opts?.limit ?? 20;
   const maxMsgsPerConv = opts?.maxMessagesPerConversation ?? 3;
@@ -258,7 +275,7 @@ export function searchConversations(
         FROM messages_fts f
         JOIN messages m ON m.id = f.message_id
         JOIN conversations c ON c.id = m.conversation_id
-        WHERE messages_fts MATCH ? AND c.conversation_type NOT IN ('background', 'scheduled') AND c.archived_at IS NULL
+        WHERE messages_fts MATCH ? AND c.conversation_type NOT IN ('background', 'scheduled', 'private') AND COALESCE(c.group_id, 'system:all') NOT IN ('system:background', 'system:scheduled') AND c.archived_at IS NULL
         LIMIT 1000
       `,
         ftsMatch,
@@ -283,7 +300,7 @@ export function searchConversations(
       SELECT DISTINCT m.conversation_id
       FROM messages m
       JOIN conversations c ON c.id = m.conversation_id
-      WHERE m.content LIKE ? ESCAPE '\\' AND c.conversation_type NOT IN ('background', 'scheduled') AND c.archived_at IS NULL
+      WHERE m.content LIKE ? ESCAPE '\\' AND c.conversation_type NOT IN ('background', 'scheduled', 'private') AND COALESCE(c.group_id, 'system:all') NOT IN ('system:background', 'system:scheduled') AND c.archived_at IS NULL
       LIMIT 1000
     `,
       likePattern,
@@ -297,7 +314,8 @@ export function searchConversations(
     .from(conversations)
     .where(
       and(
-        sql`${conversations.conversationType} NOT IN ('background', 'scheduled')`,
+        sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private')`,
+        sql`COALESCE(group_id, 'system:all') NOT IN ('system:background', 'system:scheduled')`,
         sql`${conversations.title} LIKE ${titlePattern} ESCAPE '\\'`,
         sql`${conversations.archivedAt} IS NULL`,
       ),
@@ -399,29 +417,68 @@ export function searchConversations(
  * text; we extract a readable snippet in either case.
  */
 export function buildExcerpt(rawContent: string, query: string): string {
+  return buildExcerptWithExternalContentMode(rawContent, query, "display");
+}
+
+/**
+ * Build an excerpt for model-facing recall evidence. Unlike display excerpts,
+ * this keeps complete external_content envelopes around untrusted snippets so
+ * the model still sees clear third-party content boundaries.
+ */
+export function buildRecallEvidenceExcerpt(
+  rawContent: string,
+  query: string,
+): string {
+  return buildExcerptWithExternalContentMode(rawContent, query, "preserve");
+}
+
+function buildExcerptWithExternalContentMode(
+  rawContent: string,
+  query: string,
+  externalContentMode: "display" | "preserve",
+): string {
   // Try to extract plain text from JSON content blocks first.
   let text = rawContent;
   try {
     const parsed = JSON.parse(rawContent);
     if (Array.isArray(parsed)) {
       const parts: string[] = [];
+      let preservedExternalContent = false;
       for (const block of parsed) {
         if (typeof block === "object" && block != null) {
           if (block.type === "text" && typeof block.text === "string") {
-            parts.push(block.text);
+            if (externalContentMode === "display") {
+              parts.push(unwrapExternalContentForDisplay(block.text));
+            } else {
+              const excerpt = buildRecallEvidenceText(block.text, query);
+              parts.push(excerpt.text);
+              preservedExternalContent ||= excerpt.preservedExternalContent;
+            }
           } else if (
             block.type === "tool_result" ||
             block.type === "web_search_tool_result"
           ) {
             const inner = Array.isArray(block.content) ? block.content : [];
             for (const ib of inner) {
-              if (ib?.type === "text" && typeof ib.text === "string")
-                parts.push(ib.text);
+              if (ib?.type === "text" && typeof ib.text === "string") {
+                if (externalContentMode === "display") {
+                  parts.push(unwrapExternalContentForDisplay(ib.text));
+                } else {
+                  const excerpt = buildRecallEvidenceText(ib.text, query);
+                  parts.push(excerpt.text);
+                  preservedExternalContent ||= excerpt.preservedExternalContent;
+                }
+              }
             }
           }
         }
       }
-      if (parts.length > 0) text = parts.join(" ");
+      if (parts.length > 0) {
+        text = parts.join(" ");
+        if (externalContentMode === "preserve" && preservedExternalContent) {
+          return text;
+        }
+      }
     } else if (typeof parsed === "string") {
       text = parsed;
     }
@@ -429,6 +486,53 @@ export function buildExcerpt(rawContent: string, query: string): string {
     // Not JSON — use as-is
   }
 
+  if (externalContentMode === "display") {
+    text = unwrapExternalContentForDisplay(text);
+  } else {
+    const envelope = parseExternalContentEnvelope(text);
+    if (envelope) {
+      const innerExcerpt = buildExcerptFromText(envelope.content, query);
+      return wrapRecallEvidenceExcerpt(
+        innerExcerpt,
+        envelope.source,
+        envelope.origin,
+      );
+    }
+  }
+
+  return buildExcerptFromText(text, query);
+}
+
+function buildRecallEvidenceText(
+  text: string,
+  query: string,
+): { text: string; preservedExternalContent: boolean } {
+  const envelope = parseExternalContentEnvelope(text);
+  if (!envelope) {
+    return { text, preservedExternalContent: false };
+  }
+  const innerExcerpt = buildExcerptFromText(envelope.content, query);
+  return {
+    text: wrapRecallEvidenceExcerpt(
+      innerExcerpt,
+      envelope.source,
+      envelope.origin,
+    ),
+    preservedExternalContent: true,
+  };
+}
+
+function wrapRecallEvidenceExcerpt(
+  excerpt: string,
+  source: UntrustedContentSource,
+  origin?: string,
+): string {
+  return origin
+    ? wrapUntrustedContent(excerpt, { source, sourceDetail: origin })
+    : wrapUntrustedContent(excerpt, { source });
+}
+
+function buildExcerptFromText(text: string, query: string): string {
   const WINDOW = 100;
   const lowerText = text.toLowerCase();
   const lowerQuery = query.toLowerCase();

package/src/memory/conversation-title-service.ts

@@ -39,6 +39,7 @@ export type TitleOrigin =
   | "task_submit"
   | "updates_bulletin"
   | "memory_consolidation"
+  | "memory_retrospective"
   | "misc";
 
 export interface TitleContext {

package/src/memory/conversation-types.ts

@@ -0,0 +1,16 @@
+// Re-exports the canonical conversation-type union (defined alongside the
+// create path in `conversation-crud.ts`) under a read-side name and provides
+// the shared "is this a non-interactive / background conversation?" predicate
+// used by notification-feed and memory filters.
+
+import type { ConversationCreateType } from "./conversation-crud.js";
+
+export type ConversationType = ConversationCreateType;
+
+// Tolerant of null/undefined/unknown strings so it can be called directly on
+// raw DB column values without pre-validation.
+export function isBackgroundConversationType(
+  t: ConversationType | string | null | undefined,
+): boolean {
+  return t === "background" || t === "scheduled";
+}

package/src/memory/db-init.ts

@@ -32,6 +32,7 @@ import {
   createMessagesFts,
   createNotificationTables,
   createOAuthTables,
+  createOnboardingEventsTable,
   createScopedApprovalGrantsTable,
   createSequenceTables,
   createTasksAndWorkItemsTables,
@@ -39,6 +40,7 @@ import {
   migrate230AcpSessionHistory,
   migrate231RepairMemoryGraphEventDates,
   migrateActivationState,
+  migrateActivationStateFkCascade,
   migrateAddConversationInferenceProfile,
   migrateAddSourceTypeColumns,
   migrateAssistantContactMetadata,
@@ -46,6 +48,7 @@ import {
   migrateBackfillContactInteractionStats,
   migrateBackfillGuardianPrincipalId,
   migrateBackfillInlineAttachmentsToDisk,
+  migrateBackfillProviderConnectionLabel,
   migrateBackfillUsageCacheAccounting,
   migrateCallSessionInviteMetadata,
   migrateCallSessionMode,
@@ -63,6 +66,7 @@ import {
   migrateContactsUserFileColumn,
   migrateConversationForkLineage,
   migrateConversationHostAccess,
+  migrateConversationInferenceProfileSession,
   migrateConversationsArchivedAt,
   migrateConversationsLastMessageAt,
   migrateConversationsThreadTypeIndex,
@@ -71,6 +75,7 @@ import {
   migrateCreateMemoryGraphNodeEdits,
   migrateCreateMemoryGraphTables,
   migrateCreateMemoryRecallLogs,
+  migrateCreateProviderConnections,
   migrateCreateThreadStartersTable,
   migrateCreateTraceEventsTable,
   migrateDeletePrivateConversations,
@@ -90,6 +95,7 @@ import {
   migrateDropSetupSkillIdColumn,
   migrateDropSimplifiedMemory,
   migrateDropUsageCompositeIndexes,
+  migrateExternalConversationBindingThreadId,
   migrateFkCascadeRebuilds,
   migrateGuardianActionFollowup,
   migrateGuardianActionSupersession,
@@ -112,10 +118,13 @@ import {
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
   migrateMemoryRecallLogsQueryContext,
+  migrateMemoryRetrospectiveState,
   migrateMemoryV2ActivationLogs,
+  migrateMessageBookmarks,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
   migrateNormalizePhoneIdentities,
+  migrateNormalizeSlackExternalContent,
   migrateNormalizeUserFileByPrincipal,
   migrateNotificationDeliveryThreadDecision,
   migrateOAuthAppsClientSecretPath,
@@ -133,6 +142,7 @@ import {
   migrateOAuthProvidersScopeSeparator,
   migrateOAuthProvidersTokenAuthMethodDefault,
   migrateOAuthProvidersTokenExchangeBodyFormat,
+  migrateProviderConnectionStatusLabel,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
   migrateRenameConversationTypeColumn,
@@ -399,6 +409,7 @@ export function initializeDb(): void {
     migrate230AcpSessionHistory,
     migrate231RepairMemoryGraphEventDates,
     migrateActivationState,
+    migrateActivationStateFkCascade,
     migrateMemoryV2ActivationLogs,
     migrateCreateDocumentConversations,
     migrateLlmUsageAttribution,
@@ -410,6 +421,15 @@ export function initializeDb(): void {
     },
     migrateScheduleRetryPolicy,
     migrateTraceEventsCreatedAtIndex,
+    migrateConversationInferenceProfileSession,
+    migrateMessageBookmarks,
+    migrateCreateProviderConnections,
+    migrateProviderConnectionStatusLabel,
+    migrateMemoryRetrospectiveState,
+    migrateBackfillProviderConnectionLabel,
+    migrateExternalConversationBindingThreadId,
+    createOnboardingEventsTable,
+    migrateNormalizeSlackExternalContent,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/delivery-crud.ts

@@ -5,11 +5,17 @@
  * finding messages by source identifiers, and managing raw payload storage.
  */
 
-import { and, eq, isNotNull } from "drizzle-orm";
+import { and, eq, isNotNull, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { readSlackMetadataFromMessageMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
-import { getOrCreateConversation } from "./conversation-key-store.js";
+import { selectSlackMetaCandidateMetadata } from "./conversation-crud.js";
+import {
+  getConversationByKey,
+  getOrCreateConversation,
+  setConversationKeyIfAbsent,
+} from "./conversation-key-store.js";
 import { getDb } from "./db-connection.js";
 import { channelInboundEvents, conversations } from "./schema.js";
 
@@ -23,6 +29,144 @@ export interface InboundResult {
 export interface RecordInboundOptions {
   sourceMessageId?: string;
   assistantId?: string;
+  sourceThreadId?: string;
+}
+
+const SLACK_LEGACY_THREAD_EVIDENCE_BATCH_SIZE = 50;
+const SLACK_LEGACY_THREAD_EVIDENCE_MAX_SCAN = 500;
+
+function buildScopedConversationKeyForAssistant(
+  assistantId: string,
+  sourceChannel: string,
+  externalChatId: string,
+  sourceThreadId?: string | null,
+): string {
+  const threadId = sourceThreadId?.trim();
+  if (sourceChannel === "slack" && threadId) {
+    return `asst:${assistantId}:${sourceChannel}:${externalChatId}:thread:${threadId}`;
+  }
+  return `asst:${assistantId}:${sourceChannel}:${externalChatId}`;
+}
+
+export function buildScopedConversationKey(
+  sourceChannel: string,
+  externalChatId: string,
+  sourceThreadId?: string | null,
+): string {
+  return buildScopedConversationKeyForAssistant(
+    DAEMON_INTERNAL_ASSISTANT_ID,
+    sourceChannel,
+    externalChatId,
+    sourceThreadId,
+  );
+}
+
+function legacySlackConversationHasThreadEvidence(
+  conversationId: string,
+  externalChatId: string,
+  sourceThreadId: string,
+): boolean {
+  const db = getDb();
+  const inboundEvidence = db
+    .select({ id: channelInboundEvents.id })
+    .from(channelInboundEvents)
+    .where(
+      and(
+        eq(channelInboundEvents.conversationId, conversationId),
+        eq(channelInboundEvents.sourceChannel, "slack"),
+        eq(channelInboundEvents.externalChatId, externalChatId),
+        or(
+          eq(channelInboundEvents.sourceMessageId, sourceThreadId),
+          eq(channelInboundEvents.externalMessageId, sourceThreadId),
+        ),
+      ),
+    )
+    .get();
+
+  if (inboundEvidence) {
+    return true;
+  }
+
+  let offset = 0;
+  while (offset < SLACK_LEGACY_THREAD_EVIDENCE_MAX_SCAN) {
+    const remaining = SLACK_LEGACY_THREAD_EVIDENCE_MAX_SCAN - offset;
+    const batchLimit = Math.min(
+      SLACK_LEGACY_THREAD_EVIDENCE_BATCH_SIZE,
+      remaining,
+    );
+    const metadataRows = selectSlackMetaCandidateMetadata(
+      conversationId,
+      batchLimit,
+      offset,
+      { includeFlatLegacy: true },
+    );
+
+    if (metadataRows.length === 0) return false;
+    for (const metadata of metadataRows) {
+      const slackMeta = readSlackMetadataFromMessageMetadata(metadata, {
+        allowFlatLegacy: true,
+      });
+      if (
+        slackMeta?.channelId === externalChatId &&
+        slackMeta.threadTs === sourceThreadId
+      ) {
+        return true;
+      }
+    }
+
+    if (metadataRows.length < batchLimit) return false;
+    offset += metadataRows.length;
+  }
+
+  return false;
+}
+
+function resolveInboundConversation(
+  assistantId: string,
+  sourceChannel: string,
+  externalChatId: string,
+  sourceThreadId?: string | null,
+): { conversationId: string } {
+  const threadedKey = buildScopedConversationKeyForAssistant(
+    assistantId,
+    sourceChannel,
+    externalChatId,
+    sourceThreadId,
+  );
+
+  const threadId = sourceThreadId?.trim();
+  if (sourceChannel !== "slack" || !threadId) {
+    return getOrCreateConversation(threadedKey);
+  }
+
+  const threadedMapping = getConversationByKey(threadedKey);
+  if (threadedMapping) {
+    return { conversationId: threadedMapping.conversationId };
+  }
+
+  const legacyKey = buildScopedConversationKeyForAssistant(
+    assistantId,
+    sourceChannel,
+    externalChatId,
+    null,
+  );
+  const legacyMapping = getConversationByKey(legacyKey);
+  if (
+    legacyMapping &&
+    legacySlackConversationHasThreadEvidence(
+      legacyMapping.conversationId,
+      externalChatId,
+      threadId,
+    )
+  ) {
+    setConversationKeyIfAbsent(threadedKey, legacyMapping.conversationId);
+    const aliasedMapping = getConversationByKey(threadedKey);
+    if (aliasedMapping) {
+      return { conversationId: aliasedMapping.conversationId };
+    }
+  }
+
+  return getOrCreateConversation(threadedKey);
 }
 
 /**
@@ -62,8 +206,12 @@ export function recordInbound(
   }
 
   const assistantId = options?.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID;
-  const scopedKey = `asst:${assistantId}:${sourceChannel}:${externalChatId}`;
-  const mapping = getOrCreateConversation(scopedKey);
+  const mapping = resolveInboundConversation(
+    assistantId,
+    sourceChannel,
+    externalChatId,
+    options?.sourceThreadId,
+  );
   const now = Date.now();
   const eventId = uuid();
 
@@ -176,4 +324,3 @@ export function clearPayload(eventId: string): void {
     .where(eq(channelInboundEvents.id, eventId))
     .run();
 }
-

package/src/memory/embedding-backend.ts

@@ -2,9 +2,10 @@ import { createHash } from "node:crypto";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getOllamaBaseUrlEnv } from "../config/env.js";
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import type { AssistantConfig } from "../config/types.js";
-import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
-import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
+import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
+import { resolveManagedProxyContext } from "../providers/platform-proxy/context.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
 import { GeminiEmbeddingBackend } from "./embedding-gemini.js";
@@ -310,7 +311,7 @@ export async function selectEmbeddingBackend(
   ) {
     const proxyCtx = await resolveManagedProxyContext();
     if (proxyCtx.enabled) {
-      const meta = MANAGED_PROVIDER_META["gemini"];
+      const meta = PLATFORM_PROVIDER_META["gemini"];
       if (meta?.managed && meta.proxyPath) {
         const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
         const managedModel = config.memory.embeddings.geminiModel;
@@ -684,7 +685,7 @@ async function selectFallbackBackends(
         ) {
           // Try managed proxy Gemini as fallback when no direct key exists.
           const proxyCtx = await resolveManagedProxyContext();
-          const meta = MANAGED_PROVIDER_META["gemini"];
+          const meta = PLATFORM_PROVIDER_META["gemini"];
           if (proxyCtx.enabled && meta?.managed && meta.proxyPath) {
             const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
             const managedModel = config.memory.embeddings.geminiModel;
@@ -778,7 +779,7 @@ export async function selectedBackendSupportsMultimodal(
 
 async function isOllamaConfigured(config: AssistantConfig): Promise<boolean> {
   return (
-    config.llm.default.provider === "ollama" ||
+    resolveCallSiteConfig("mainAgent", config.llm).provider === "ollama" ||
     Boolean(await getProviderKeyAsync("ollama")) ||
     Boolean(getOllamaBaseUrlEnv())
   );

package/src/memory/embedding-runtime-manager.ts

@@ -44,7 +44,7 @@ const JINJA_VERSION = "0.5.5";
  * scripts when the worker IPC contract or spawn-args list changes (without
  * requiring an `@huggingface/transformers` version bump).
  */
-const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}_workers-v2`;
+const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}_workers-v3`;
 
 const WORKER_FILENAME = "embed-worker.mjs";
 const RERANK_WORKER_FILENAME = "rerank-worker.mjs";
@@ -252,7 +252,6 @@ async function processQueue() {
         text_pair: passages,
         padding: true,
         truncation: true,
-        return_tensors: 'pt',
       });
       const out = await session(inputs);
       const logits = out.logits.data;