@vellumai/assistant 0.5.15 → 0.6.0

package/src/memory/search/semantic.ts

@@ -8,15 +8,42 @@ import type {
   QdrantSparseVector,
 } from "../qdrant-client.js";
 import { getQdrantClient } from "../qdrant-client.js";
-import {
-  conversations,
-  memoryItems,
-  memoryItemSources,
-  memorySegments,
-  memorySummaries,
-} from "../schema.js";
-import { computeRecencyScore } from "./ranking.js";
-import type { Candidate } from "./types.js";
+import { conversations, memorySegments, memorySummaries } from "../schema.js";
+// ── Types (inlined from deleted types.ts) ──────────────────────────
+
+type CandidateType = "segment" | "item" | "summary" | "media";
+
+export interface Candidate {
+  key: string;
+  type: CandidateType;
+  id: string;
+  source: "semantic";
+  text: string;
+  kind: string;
+  modality?: "text" | "image" | "audio" | "video";
+  conversationId?: string;
+  messageId?: string;
+  confidence: number;
+  importance: number;
+  createdAt: number;
+  semantic: number;
+  recency: number;
+  finalScore: number;
+}
+
+// ── Recency scoring (inlined from deleted ranking.ts) ──────────────
+
+/**
+ * Logarithmic recency decay (ACT-R inspired).
+ *
+ *   1 day -> 0.50, 7 days -> 0.25, 30 days -> 0.17
+ *   90 days -> 0.15, 1 year -> 0.12, 2 years -> 0.10
+ */
+function computeRecencyScore(createdAt: number): number {
+  const ageMs = Math.max(0, Date.now() - createdAt);
+  const ageDays = ageMs / (24 * 60 * 60 * 1000);
+  return 1 / (1 + Math.log2(1 + ageDays));
+}
 
 const _log = getLogger("semantic-search");
 
@@ -27,7 +54,7 @@ export async function semanticSearch(
   limit: number,
   excludedMessageIds: string[] = [],
   scopeIds?: string[],
-  sparseVector?: QdrantSparseVector,
+  sparseVector?: QdrantSparseVector
 ): Promise<Candidate[]> {
   if (limit <= 0) return [];
 
@@ -52,31 +79,28 @@ export async function semanticSearch(
         filter,
         limit: fetchLimit,
         prefetchLimit: fetchLimit,
-      }),
+      })
     );
   } else {
     results = await withQdrantBreaker(() =>
       qdrant.searchWithFilter(
         queryVector,
         fetchLimit,
-        ["item", "summary", "segment", "media"],
+        ["summary", "segment", "media"],
         excludedMessageIds,
-        scopeIds,
-      ),
+        scopeIds
+      )
     );
   }
 
   const db = getDb();
 
   // Batch-fetch all backing records upfront to avoid N+1 queries per result
-  const itemTargetIds: string[] = [];
   const summaryTargetIds: string[] = [];
   const segmentTargetIds: string[] = [];
   const mediaConversationIds: string[] = [];
   for (const r of results) {
-    if (r.payload.target_type === "item")
-      itemTargetIds.push(r.payload.target_id);
-    else if (r.payload.target_type === "summary")
+    if (r.payload.target_type === "summary")
       summaryTargetIds.push(r.payload.target_id);
     else if (r.payload.target_type === "segment")
       segmentTargetIds.push(r.payload.target_id);
@@ -84,33 +108,6 @@ export async function semanticSearch(
       mediaConversationIds.push(r.payload.conversation_id);
   }
 
-  const itemsMap = new Map<string, typeof memoryItems.$inferSelect>();
-  if (itemTargetIds.length > 0) {
-    const allItems = db
-      .select()
-      .from(memoryItems)
-      .where(inArray(memoryItems.id, itemTargetIds))
-      .all();
-    for (const item of allItems) itemsMap.set(item.id, item);
-  }
-
-  const sourcesMap = new Map<string, string[]>();
-  if (itemTargetIds.length > 0) {
-    const allSources = db
-      .select({
-        memoryItemId: memoryItemSources.memoryItemId,
-        messageId: memoryItemSources.messageId,
-      })
-      .from(memoryItemSources)
-      .where(inArray(memoryItemSources.memoryItemId, itemTargetIds))
-      .all();
-    for (const s of allSources) {
-      const existing = sourcesMap.get(s.memoryItemId);
-      if (existing) existing.push(s.messageId);
-      else sourcesMap.set(s.memoryItemId, [s.messageId]);
-    }
-  }
-
   const summariesMap = new Map<string, typeof memorySummaries.$inferSelect>();
   if (scopeIds && summaryTargetIds.length > 0) {
     const allSummaries = db
@@ -148,8 +145,6 @@ export async function semanticSearch(
     for (const row of rows) mediaScopeMap.set(row.id, row.memoryScopeId);
   }
 
-  const excludedSet =
-    excludedMessageIds.length > 0 ? new Set(excludedMessageIds) : null;
 
   const candidates: Candidate[] = [];
   for (const result of results) {
@@ -159,29 +154,8 @@ export async function semanticSearch(
     const createdAt = payload.created_at ?? Date.now();
 
     if (payload.target_type === "item") {
-      const item = itemsMap.get(payload.target_id);
-      if (!item || item.status !== "active" || item.invalidAt != null) continue;
-      if (scopeIds && !scopeIds.includes(item.scopeId)) continue;
-      const sources = sourcesMap.get(payload.target_id);
-      if (!sources || sources.length === 0) continue;
-      if (excludedSet) {
-        const hasNonExcluded = sources.some((msgId) => !excludedSet.has(msgId));
-        if (!hasNonExcluded) continue;
-      }
-      candidates.push({
-        key: `item:${payload.target_id}`,
-        type: "item",
-        id: payload.target_id,
-        source: "semantic",
-        text: `${item.subject}: ${item.statement}`,
-        kind: item.kind,
-        confidence: item.confidence,
-        importance: item.importance ?? 0.5,
-        createdAt: item.lastSeenAt,
-        semantic,
-        recency: computeRecencyScore(item.lastSeenAt),
-        finalScore: 0,
-      });
+      // Legacy item vectors — skip (table dropped, Qdrant cleanup pending)
+      continue;
     } else if (payload.target_type === "summary") {
       if (scopeIds) {
         const summary = summariesMap.get(payload.target_id);
@@ -284,33 +258,15 @@ export async function semanticSearch(
  */
 function buildHybridFilter(
   excludeMessageIds: string[],
-  scopeIds?: string[],
+  scopeIds?: string[]
 ): Record<string, unknown> {
   const mustConditions: Array<Record<string, unknown>> = [
     {
       key: "target_type",
-      match: { any: ["item", "summary", "segment", "media"] },
+      match: { any: ["summary", "segment", "media"] },
     },
   ];
 
-  if (excludeMessageIds.length > 0) {
-    // Only require status=active for items; segments and summaries don't have a status field
-    mustConditions.push({
-      should: [
-        {
-          must: [
-            { key: "target_type", match: { value: "item" } },
-            { key: "status", match: { value: "active" } },
-          ],
-        },
-        {
-          key: "target_type",
-          match: { any: ["segment", "summary", "media"] },
-        },
-      ],
-    });
-  }
-
   // Scope filtering: accept points whose memory_scope_id matches one of the
   // allowed scopes, OR points that lack the field entirely (legacy data).
   // Post-query DB filtering remains as defense-in-depth for legacy points.
@@ -346,6 +302,6 @@ export function mapCosineToUnit(value: number): number {
 export function isQdrantConnectionError(err: unknown): boolean {
   if (!(err instanceof Error)) return false;
   return /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|fetch failed/i.test(
-    err.message,
+    err.message
   );
 }

package/src/memory/slack-thread-store.ts

@@ -78,6 +78,23 @@ export function extractThreadTsFromCallbackUrl(
   }
 }
 
+/**
+ * Extract the messageTs from a Slack reply callback URL, if present.
+ * The gateway encodes messageTs for non-threaded DMs so the runtime
+ * can target the original message for emoji-based indicators.
+ */
+export function extractMessageTsFromCallbackUrl(
+  callbackUrl: string | undefined,
+): string | null {
+  if (!callbackUrl) return null;
+  try {
+    const url = new URL(callbackUrl);
+    return url.searchParams.get("messageTs");
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Extract the channel from a Slack reply callback URL, if present.
  */

package/src/memory/task-memory-cleanup.ts

@@ -24,62 +24,41 @@ export function isConversationFailed(conversationId: string): boolean {
 }
 
 /**
- * Invalidate assistant-extracted memory items sourced *exclusively* from
- * messages in the given conversation. Called when a background task or
- * schedule fails — the assistant's optimistic claims (e.g., "I booked an
- * appointment") are not trustworthy if the task didn't complete.
+ * Invalidate assistant-inferred memory graph nodes sourced *exclusively* from
+ * the given conversation. Called when a background task or schedule fails —
+ * the assistant's optimistic claims are not trustworthy if the task didn't
+ * complete.
  *
- * The failed state is derived from durable storage (task_runs / cron_runs),
- * so any pending or future extraction jobs for this conversation are blocked
- * from creating new assistant-extracted items — even after daemon restarts.
- *
- * Items that also have sources from other conversations are left alone
- * only when those conversations come from non-failed task/schedule runs
- * (or are ordinary user conversations). This prevents cascading failures
- * from mutually protecting each other — if two conversations both source
- * a memory item and both fail, the item is correctly invalidated.
+ * Nodes that also have sources from other non-failed conversations are left
+ * alone (corroboration). Uses the `source_conversations` JSON array to
+ * determine provenance.
  */
 export function invalidateAssistantInferredItemsForConversation(
   conversationId: string,
 ): number {
-  // Cancel pending extraction jobs for this conversation's messages
-  // so the worker never processes them. Jobs already running will be
-  // caught by the isConversationFailed check in the extraction handler.
-  // NOTE: Only extract_items jobs are cancelled here — not embed_item or
-  // other job types. Multi-sourced items may still be valid (corroborated
-  // by other conversations), and their embedding jobs must not be killed.
-  // The broader cancelPendingJobsForConversation is used by the wipe path.
   cancelPendingExtractionJobsForConversation(conversationId);
 
   const affected = rawRun(
-    `UPDATE memory_items
-        SET status = 'invalidated',
-            invalid_at = ?
-      WHERE source_type = 'extraction'
-        AND source_message_role = 'assistant'
-        AND status = 'active'
-        AND id IN (
-          SELECT mis.memory_item_id
-            FROM memory_item_sources mis
-            JOIN messages m ON m.id = mis.message_id
-           WHERE m.conversation_id = ?
+    `UPDATE memory_graph_nodes
+        SET fidelity = 'gone',
+            last_accessed = ?
+      WHERE source_type = 'inferred'
+        AND fidelity != 'gone'
+        AND EXISTS (
+          SELECT 1 FROM json_each(source_conversations) jc
+           WHERE jc.value = ?
         )
         AND NOT EXISTS (
-          SELECT 1
-            FROM memory_item_sources mis2
-            JOIN messages m2 ON m2.id = mis2.message_id
-           WHERE mis2.memory_item_id = memory_items.id
-             AND m2.conversation_id != ?
-             -- Only count as corroboration if the other conversation is NOT
-             -- from a failed task run or failed schedule run.
+          SELECT 1 FROM json_each(source_conversations) jc2
+           WHERE jc2.value != ?
              AND NOT EXISTS (
                SELECT 1 FROM task_runs tr
-                WHERE tr.conversation_id = m2.conversation_id
+                WHERE tr.conversation_id = jc2.value
                   AND tr.status = 'failed'
              )
              AND NOT EXISTS (
                SELECT 1 FROM cron_runs cr
-                WHERE cr.conversation_id = m2.conversation_id
+                WHERE cr.conversation_id = jc2.value
                   AND cr.status = 'error'
              )
         )`,
@@ -91,7 +70,7 @@ export function invalidateAssistantInferredItemsForConversation(
   if (affected > 0) {
     log.info(
       { conversationId, affected },
-      "Invalidated assistant-inferred memory items after task failure",
+      "Invalidated assistant-inferred memory graph nodes after task failure",
     );
   }
 
@@ -103,7 +82,7 @@ export function invalidateAssistantInferredItemsForConversation(
  * Covers every job type: `extract_items`, `embed_attachment` (keyed by messageId),
  * `embed_segment` (keyed by segmentId via memory_segments),
  * `build_conversation_summary` (keyed by conversationId),
- * and `embed_item` (keyed by itemId sourced from the conversation's messages).
+ * and `embed_graph_node` (keyed by nodeId sourced from the conversation).
  */
 export function cancelPendingJobsForConversation(
   conversationId: string,
@@ -155,18 +134,17 @@ export function cancelPendingJobsForConversation(
     conversationId,
   );
 
-  // Jobs keyed by itemId: embed_item (items sourced from this conversation)
+  // Jobs keyed by nodeId: embed_graph_node (nodes sourced from this conversation)
   total += rawRun(
     `UPDATE memory_jobs
         SET status = 'failed',
             last_error = ?,
             updated_at = ?
       WHERE status IN ('pending', 'running')
-        AND json_extract(payload, '$.itemId') IN (
-          SELECT mis.memory_item_id
-            FROM memory_item_sources mis
-            JOIN messages m ON m.id = mis.message_id
-           WHERE m.conversation_id = ?
+        AND json_extract(payload, '$.nodeId') IN (
+          SELECT mgn.id
+            FROM memory_graph_nodes mgn, json_each(mgn.source_conversations) jc
+           WHERE jc.value = ?
         )`,
     reason,
     now,
@@ -186,8 +164,8 @@ export function cancelPendingJobsForConversation(
 /**
  * Cancel only pending/running `extract_items` jobs for messages in the
  * given conversation. Used by the task-failure path where we want to
- * stop new extractions but must NOT cancel `embed_item` jobs — those
- * items may be multi-sourced and still valid.
+ * stop new extractions but must NOT cancel `embed_graph_node` jobs —
+ * those nodes may be multi-sourced and still valid.
  */
 function cancelPendingExtractionJobsForConversation(
   conversationId: string,

package/src/messaging/providers/outlook/adapter.ts

@@ -0,0 +1,200 @@
+/**
+ * Outlook messaging provider adapter.
+ *
+ * Maps Microsoft Graph API responses to the platform-agnostic messaging types
+ * and implements the MessagingProvider interface.
+ */
+
+import type { OAuthConnection } from "../../../oauth/connection.js";
+import type { MessagingProvider } from "../../provider.js";
+import type {
+  ConnectionInfo,
+  Conversation,
+  HistoryOptions,
+  ListOptions,
+  Message,
+  SearchOptions,
+  SearchResult,
+  SendOptions,
+  SendResult,
+} from "../../provider-types.js";
+import * as outlook from "./client.js";
+import type { OutlookMessage } from "./types.js";
+
+function requireConnection(
+  connection: OAuthConnection | undefined,
+): OAuthConnection {
+  if (!connection) {
+    throw new Error(
+      "Outlook requires an OAuth connection — is the account connected?",
+    );
+  }
+  return connection;
+}
+
+function mapOutlookMessage(msg: OutlookMessage): Message {
+  const senderEmail = msg.from?.emailAddress?.address ?? "";
+  const senderName = msg.from?.emailAddress?.name || senderEmail || "Unknown";
+
+  return {
+    id: msg.id,
+    conversationId: msg.conversationId,
+    sender: {
+      id: senderEmail,
+      name: senderName,
+      email: senderEmail,
+    },
+    text: msg.body.contentType === "text" ? msg.body.content : msg.bodyPreview,
+    timestamp: new Date(msg.receivedDateTime).getTime(),
+    threadId: msg.conversationId,
+    platform: "outlook",
+    hasAttachments: msg.hasAttachments ?? false,
+    metadata: {
+      subject: msg.subject,
+      categories: msg.categories,
+      isRead: msg.isRead,
+      parentFolderId: msg.parentFolderId,
+    },
+  };
+}
+
+const MESSAGE_SELECT_FIELDS =
+  "id,conversationId,subject,bodyPreview,body,from,toRecipients,receivedDateTime,isRead,hasAttachments,parentFolderId,categories,flag";
+
+export const outlookMessagingProvider: MessagingProvider = {
+  id: "outlook",
+  displayName: "Outlook",
+  credentialService: "outlook",
+  capabilities: new Set([
+    "threads",
+    "folders",
+    "categories",
+    "drafts_native",
+    "archive",
+    "unsubscribe",
+  ]),
+
+  async testConnection(connection?: OAuthConnection): Promise<ConnectionInfo> {
+    const conn = requireConnection(connection);
+    const profile = await outlook.getProfile(conn);
+    return {
+      connected: true,
+      user: profile.mail || profile.userPrincipalName,
+      platform: "outlook",
+    };
+  },
+
+  async listConversations(
+    connection: OAuthConnection | undefined,
+    _options?: ListOptions,
+  ): Promise<Conversation[]> {
+    const conn = requireConnection(connection);
+    const folders = await outlook.listMailFolders(conn);
+    return folders.map((folder) => ({
+      id: folder.id,
+      name: folder.displayName,
+      type: "inbox" as const,
+      platform: "outlook",
+      unreadCount: folder.unreadItemCount ?? 0,
+      lastActivityAt: Date.now(),
+      metadata: {
+        totalItemCount: folder.totalItemCount,
+        childFolderCount: folder.childFolderCount,
+      },
+    }));
+  },
+
+  async getHistory(
+    connection: OAuthConnection | undefined,
+    conversationId: string,
+    options?: HistoryOptions,
+  ): Promise<Message[]> {
+    const conn = requireConnection(connection);
+    const result = await outlook.listMessages(conn, {
+      folderId: conversationId,
+      top: options?.limit ?? 50,
+      orderby: "receivedDateTime desc",
+      select: MESSAGE_SELECT_FIELDS,
+    });
+    return (result.value ?? []).map(mapOutlookMessage);
+  },
+
+  async search(
+    connection: OAuthConnection | undefined,
+    query: string,
+    options?: SearchOptions,
+  ): Promise<SearchResult> {
+    const conn = requireConnection(connection);
+    const result = await outlook.searchMessages(conn, query, {
+      top: options?.count ?? 20,
+    });
+    const messages = result.value ?? [];
+    return {
+      total: result["@odata.count"] ?? messages.length,
+      messages: messages.map(mapOutlookMessage),
+      hasMore: !!result["@odata.nextLink"],
+    };
+  },
+
+  async sendMessage(
+    connection: OAuthConnection | undefined,
+    conversationId: string,
+    text: string,
+    options?: SendOptions,
+  ): Promise<SendResult> {
+    const conn = requireConnection(connection);
+
+    if (options?.inReplyTo) {
+      await outlook.replyToMessage(conn, options.inReplyTo, text);
+      return {
+        id: "",
+        timestamp: Date.now(),
+        conversationId,
+        threadId: options?.threadId,
+      };
+    }
+
+    await outlook.sendMessage(conn, {
+      message: {
+        subject: options?.subject ?? "",
+        body: { contentType: "text", content: text },
+        toRecipients: [{ emailAddress: { address: conversationId } }],
+      },
+    });
+
+    // Microsoft Graph's sendMail returns 202 with no body
+    return {
+      id: "",
+      timestamp: Date.now(),
+      conversationId,
+      threadId: options?.threadId,
+    };
+  },
+
+  async getThreadReplies(
+    connection: OAuthConnection | undefined,
+    _conversationId: string,
+    threadId: string,
+    options?: HistoryOptions,
+  ): Promise<Message[]> {
+    const conn = requireConnection(connection);
+    const result = await outlook.listMessages(conn, {
+      filter: `conversationId eq '${threadId.replace(/'/g, "''")}'`,
+      top: options?.limit ?? 50,
+      orderby: "receivedDateTime asc",
+      select: MESSAGE_SELECT_FIELDS,
+    });
+    return (result.value ?? []).map(mapOutlookMessage);
+  },
+
+  async markRead(
+    connection: OAuthConnection | undefined,
+    _conversationId: string,
+    messageId?: string,
+  ): Promise<void> {
+    const conn = requireConnection(connection);
+    if (messageId) {
+      await outlook.markMessageRead(conn, messageId);
+    }
+  },
+};