@vellumai/assistant 0.5.16 → 0.6.1

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

@@ -9,78 +9,78 @@ const log = getLogger("task-memory-cleanup");
  * so the check survives daemon restarts.
  */
 export function isConversationFailed(conversationId: string): boolean {
+  // For reused schedule conversations the same conversation_id appears in
+  // multiple cron_runs. A single failed run should NOT mark the conversation
+  // as permanently failed — only the *most recent* run for that conversation
+  // matters. We therefore check whether the latest cron_run (by created_at,
+  // which is a monotonically increasing epoch timestamp) has an error status.
+  // Note: cron_runs.id is a UUID v4 (random), so we cannot use MAX(id).
   const row = rawGet<{ found: number }>(
     `SELECT 1 AS found
        FROM (
          SELECT 1 FROM task_runs WHERE conversation_id = ? AND status = 'failed'
          UNION ALL
-         SELECT 1 FROM cron_runs WHERE conversation_id = ? AND status = 'error'
+         SELECT 1 FROM cron_runs
+          WHERE conversation_id = ?
+            AND status = 'error'
+            AND id = (
+              SELECT id FROM cron_runs WHERE conversation_id = ?
+              ORDER BY created_at DESC LIMIT 1
+            )
        )
       LIMIT 1`,
     conversationId,
     conversationId,
+    conversationId,
   );
   return row != null;
 }
 
 /**
- * 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.
- *
- * 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.
+ * 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.
  *
- * 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 (
+               -- Check only the most recent cron_run for each conversation
+               -- so reused conversations with historical errors but recent
+               -- successes are still treated as valid corroborators.
                SELECT 1 FROM cron_runs cr
-                WHERE cr.conversation_id = m2.conversation_id
+                WHERE cr.conversation_id = jc2.value
                   AND cr.status = 'error'
+                  AND cr.id = (
+                    SELECT cr2.id FROM cron_runs cr2
+                     WHERE cr2.conversation_id = jc2.value
+                     ORDER BY cr2.created_at DESC LIMIT 1
+                  )
              )
         )`,
     Date.now(),
@@ -91,7 +91,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",
     );
   }
 
@@ -100,10 +100,10 @@ export function invalidateAssistantInferredItemsForConversation(
 
 /**
  * Cancel all pending/running memory jobs referencing the given conversation.
- * Covers every job type: `extract_items`, `embed_attachment` (keyed by messageId),
+ * Covers every job type: `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).
+ * `graph_extract`, `build_conversation_summary` (keyed by conversationId),
+ * and `embed_graph_node` (keyed by nodeId sourced from the conversation).
  */
 export function cancelPendingJobsForConversation(
   conversationId: string,
@@ -112,7 +112,7 @@ export function cancelPendingJobsForConversation(
   const now = Date.now();
   let total = 0;
 
-  // Jobs keyed by messageId: extract_items, embed_attachment
+  // Jobs keyed by messageId: embed_attachment
   total += rawRun(
     `UPDATE memory_jobs
         SET status = 'failed',
@@ -127,7 +127,7 @@ export function cancelPendingJobsForConversation(
     conversationId,
   );
 
-  // Jobs keyed by conversationId: build_conversation_summary
+  // Jobs keyed by conversationId: graph_extract, build_conversation_summary
   total += rawRun(
     `UPDATE memory_jobs
         SET status = 'failed',
@@ -155,18 +155,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,
@@ -184,10 +183,10 @@ 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.
+ * Cancel only pending/running `graph_extract` jobs for the given
+ * conversation. Used by the task-failure path where we want to
+ * stop new extractions but must NOT cancel `embed_graph_node` jobs —
+ * those nodes may be multi-sourced and still valid.
  */
 function cancelPendingExtractionJobsForConversation(
   conversationId: string,
@@ -199,10 +198,8 @@ function cancelPendingExtractionJobsForConversation(
             last_error = 'conversation_failed',
             updated_at = ?
       WHERE status IN ('pending', 'running')
-        AND type = 'extract_items'
-        AND json_extract(payload, '$.messageId') IN (
-          SELECT id FROM messages WHERE conversation_id = ?
-        )`,
+        AND type = 'graph_extract'
+        AND json_extract(payload, '$.conversationId') = ?`,
     now,
     conversationId,
   );

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

@@ -65,7 +65,14 @@ export const outlookMessagingProvider: MessagingProvider = {
   id: "outlook",
   displayName: "Outlook",
   credentialService: "outlook",
-  capabilities: new Set(["threads", "folders"]),
+  capabilities: new Set([
+    "threads",
+    "folders",
+    "categories",
+    "drafts_native",
+    "archive",
+    "unsubscribe",
+  ]),
 
   async testConnection(connection?: OAuthConnection): Promise<ConnectionInfo> {
     const conn = requireConnection(connection);

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

@@ -3,10 +3,20 @@ import type {
   OAuthConnectionResponse,
 } from "../../../oauth/connection.js";
 import type {
+  OutlookAttachmentListResponse,
+  OutlookAutoReplySettings,
+  OutlookDeltaResponse,
+  OutlookDraftMessage,
+  OutlookFileAttachment,
   OutlookMailFolder,
   OutlookMailFolderListResponse,
+  OutlookMasterCategoryListResponse,
   OutlookMessage,
+  OutlookMessageFlag,
   OutlookMessageListResponse,
+  OutlookMessageRule,
+  OutlookMessageRuleListResponse,
+  OutlookRecipient,
   OutlookSendMessagePayload,
   OutlookUserProfile,
 } from "./types.js";
@@ -268,6 +278,22 @@ export async function markMessageRead(
   );
 }
 
+/** Patch arbitrary fields on a message (e.g. to update recipients on a draft). */
+export async function patchMessage(
+  connection: OAuthConnection,
+  messageId: string,
+  fields: Record<string, unknown>,
+): Promise<OutlookMessage> {
+  return request<OutlookMessage>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(fields),
+    },
+  );
+}
+
 /** Move a message to a different folder (e.g. for archiving). */
 export async function moveMessage(
   connection: OAuthConnection,
@@ -284,6 +310,84 @@ export async function moveMessage(
   );
 }
 
+/** Create a draft message in the user's Drafts folder. */
+export async function createDraft(
+  connection: OAuthConnection,
+  draft: OutlookDraftMessage,
+): Promise<OutlookMessage> {
+  return request<OutlookMessage>(connection, "/v1.0/me/messages", {
+    method: "POST",
+    body: JSON.stringify(draft),
+  });
+}
+
+/** Send an existing draft message by its ID. Returns void (202 No Content). */
+export async function sendDraft(
+  connection: OAuthConnection,
+  messageId: string,
+): Promise<void> {
+  await request<void>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}/send`,
+    {
+      method: "POST",
+    },
+  );
+}
+
+/** Create a reply draft for a message. */
+export async function createReplyDraft(
+  connection: OAuthConnection,
+  messageId: string,
+  comment?: string,
+): Promise<OutlookMessage> {
+  return request<OutlookMessage>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}/createReply`,
+    {
+      method: "POST",
+      body: JSON.stringify(comment !== undefined ? { comment } : {}),
+    },
+  );
+}
+
+/** Create a reply-all draft for a message. */
+export async function createReplyAllDraft(
+  connection: OAuthConnection,
+  messageId: string,
+  comment?: string,
+): Promise<OutlookMessage> {
+  return request<OutlookMessage>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}/createReplyAll`,
+    {
+      method: "POST",
+      body: JSON.stringify(comment !== undefined ? { comment } : {}),
+    },
+  );
+}
+
+/** Create a forward draft for a message. */
+export async function createForwardDraft(
+  connection: OAuthConnection,
+  messageId: string,
+  toRecipients?: OutlookRecipient[],
+  comment?: string,
+): Promise<OutlookMessage> {
+  const body: Record<string, unknown> = {};
+  if (toRecipients !== undefined) body.toRecipients = toRecipients;
+  if (comment !== undefined) body.comment = comment;
+
+  return request<OutlookMessage>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}/createForward`,
+    {
+      method: "POST",
+      body: JSON.stringify(body),
+    },
+  );
+}
+
 /** Max concurrent individual getMessage requests for batch fetching. */
 const BATCH_CONCURRENCY = 5;
 
@@ -309,3 +413,198 @@ export async function batchGetMessages(
   }
   return results;
 }
+
+/** List attachments on a message. */
+export async function listAttachments(
+  connection: OAuthConnection,
+  messageId: string,
+): Promise<OutlookAttachmentListResponse> {
+  return request<OutlookAttachmentListResponse>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}/attachments`,
+    undefined,
+    { $select: "id,name,contentType,size,isInline" },
+  );
+}
+
+/** Get a single attachment by ID (includes file content). */
+export async function getAttachment(
+  connection: OAuthConnection,
+  messageId: string,
+  attachmentId: string,
+): Promise<OutlookFileAttachment> {
+  return request<OutlookFileAttachment>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`,
+  );
+}
+
+/** Move a message to the Deleted Items folder. */
+export async function trashMessage(
+  connection: OAuthConnection,
+  messageId: string,
+): Promise<OutlookMessage> {
+  return request<OutlookMessage>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}/move`,
+    {
+      method: "POST",
+      body: JSON.stringify({ destinationId: "deleteditems" }),
+    },
+  );
+}
+
+/** List inbox message rules. */
+export async function listMailRules(
+  connection: OAuthConnection,
+): Promise<OutlookMessageRuleListResponse> {
+  return request<OutlookMessageRuleListResponse>(
+    connection,
+    "/v1.0/me/mailFolders/inbox/messageRules",
+  );
+}
+
+/** Create a new inbox message rule. */
+export async function createMailRule(
+  connection: OAuthConnection,
+  rule: Omit<OutlookMessageRule, "id">,
+): Promise<OutlookMessageRule> {
+  return request<OutlookMessageRule>(
+    connection,
+    "/v1.0/me/mailFolders/inbox/messageRules",
+    {
+      method: "POST",
+      body: JSON.stringify(rule),
+    },
+  );
+}
+
+/** Update the categories on a message. */
+export async function updateMessageCategories(
+  connection: OAuthConnection,
+  messageId: string,
+  categories: string[],
+): Promise<void> {
+  await request<void>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify({ categories }),
+    },
+  );
+}
+
+/** Update the flag on a message. */
+export async function updateMessageFlag(
+  connection: OAuthConnection,
+  messageId: string,
+  flag: OutlookMessageFlag,
+): Promise<void> {
+  await request<void>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify({ flag }),
+    },
+  );
+}
+
+/** List the user's master categories. */
+export async function listMasterCategories(
+  connection: OAuthConnection,
+): Promise<OutlookMasterCategoryListResponse> {
+  return request<OutlookMasterCategoryListResponse>(
+    connection,
+    "/v1.0/me/outlook/masterCategories",
+  );
+}
+
+/** Get a message with internet message headers included. */
+export async function getMessageWithHeaders(
+  connection: OAuthConnection,
+  messageId: string,
+): Promise<OutlookMessage> {
+  return request<OutlookMessage>(
+    connection,
+    `/v1.0/me/messages/${encodeURIComponent(messageId)}`,
+    undefined,
+    {
+      $select:
+        "id,subject,from,internetMessageHeaders,bodyPreview,body,hasAttachments,receivedDateTime",
+    },
+  );
+}
+
+/** Delete an inbox message rule by ID. */
+export async function deleteMailRule(
+  connection: OAuthConnection,
+  ruleId: string,
+): Promise<void> {
+  await request<void>(
+    connection,
+    `/v1.0/me/mailFolders/inbox/messageRules/${encodeURIComponent(ruleId)}`,
+    { method: "DELETE" },
+  );
+}
+
+/** Get automatic reply (out-of-office) settings. */
+export async function getAutoReplySettings(
+  connection: OAuthConnection,
+): Promise<OutlookAutoReplySettings> {
+  return request<OutlookAutoReplySettings>(
+    connection,
+    "/v1.0/me/mailboxSettings/automaticRepliesSetting",
+  );
+}
+
+/** Update automatic reply (out-of-office) settings. */
+export async function updateAutoReplySettings(
+  connection: OAuthConnection,
+  settings: OutlookAutoReplySettings,
+): Promise<void> {
+  await request<void>(connection, "/v1.0/me/mailboxSettings", {
+    method: "PATCH",
+    body: JSON.stringify({ automaticRepliesSetting: settings }),
+  });
+}
+
+/**
+ * Fetch messages via delta query for incremental sync.
+ *
+ * On the initial call, omit `deltaLink` to start a fresh delta enumeration
+ * for the given folder. On subsequent calls, pass the `@odata.deltaLink`
+ * from the previous response to get only changes since then.
+ */
+export async function listMessagesDelta(
+  connection: OAuthConnection,
+  folderId: string,
+  deltaLink?: string,
+): Promise<OutlookDeltaResponse<OutlookMessage>> {
+  if (deltaLink) {
+    // Parse the deltaLink URL and extract its query params
+    const url = new URL(deltaLink);
+    const query: Record<string, string> = {};
+    url.searchParams.forEach((v, k) => {
+      query[k] = v;
+    });
+    return request<OutlookDeltaResponse<OutlookMessage>>(
+      connection,
+      url.pathname,
+      undefined,
+      Object.keys(query).length > 0 ? query : undefined,
+    );
+  }
+
+  return request<OutlookDeltaResponse<OutlookMessage>>(
+    connection,
+    `/v1.0/me/mailFolders/${encodeURIComponent(folderId)}/messages/delta`,
+    undefined,
+    {
+      $select:
+        "id,subject,from,receivedDateTime,isRead,parentFolderId,conversationId,bodyPreview,hasAttachments",
+      $top: "50",
+    },
+  );
+}

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

@@ -28,6 +28,12 @@ export interface OutlookItemBody {
   content: string;
 }
 
+/** Internet message header (e.g. List-Unsubscribe, X-Mailer) */
+export interface OutlookInternetMessageHeader {
+  name: string;
+  value: string;
+}
+
 /** Full Outlook message from Microsoft Graph */
 export interface OutlookMessage {
   id: string;
@@ -46,6 +52,7 @@ export interface OutlookMessage {
   flag: {
     flagStatus: "notFlagged" | "flagged" | "complete";
   };
+  internetMessageHeaders?: OutlookInternetMessageHeader[];
 }
 
 /** Outlook mail folder */
@@ -75,9 +82,120 @@ export interface OutlookSendMessagePayload {
   saveToSentItems?: boolean;
 }
 
+/** Draft message for creating in Drafts folder */
+export interface OutlookDraftMessage {
+  subject: string;
+  body: OutlookItemBody;
+  toRecipients?: OutlookRecipient[];
+  ccRecipients?: OutlookRecipient[];
+  bccRecipients?: OutlookRecipient[];
+}
+
+/** Forward message payload (Graph API's /createForward returns a draft) */
+export interface OutlookForwardMessage {
+  toRecipients: OutlookRecipient[];
+  comment?: string;
+}
+
 /** Microsoft Graph user profile */
 export interface OutlookUserProfile {
   displayName: string;
   mail: string;
   userPrincipalName: string;
 }
+
+/** Outlook attachment metadata */
+export interface OutlookAttachment {
+  id: string;
+  name: string;
+  contentType: string;
+  size: number;
+  isInline: boolean;
+  "@odata.type"?: string;
+}
+
+/** Outlook file attachment with base64-encoded content */
+export interface OutlookFileAttachment extends OutlookAttachment {
+  contentBytes: string;
+}
+
+/** Outlook attachment list response (paginated) */
+export interface OutlookAttachmentListResponse {
+  value?: OutlookAttachment[];
+  "@odata.nextLink"?: string;
+}
+
+/** Outlook message flag with optional due/start dates */
+export interface OutlookMessageFlag {
+  flagStatus: "notFlagged" | "flagged" | "complete";
+  dueDateTime?: { dateTime: string; timeZone: string };
+  startDateTime?: { dateTime: string; timeZone: string };
+}
+
+/** Outlook master category */
+export interface OutlookMasterCategory {
+  displayName: string;
+  color: string;
+}
+
+/** Outlook master category list response */
+export interface OutlookMasterCategoryListResponse {
+  value?: OutlookMasterCategory[];
+}
+
+/** Predicates for matching messages in a mail rule */
+export interface OutlookMessageRulePredicates {
+  senderContains?: string[];
+  subjectContains?: string[];
+  bodyContains?: string[];
+  fromAddresses?: OutlookRecipient[];
+  hasAttachments?: boolean;
+  importance?: "low" | "normal" | "high";
+}
+
+/** Actions to take when a mail rule matches */
+export interface OutlookMessageRuleActions {
+  moveToFolder?: string;
+  delete?: boolean;
+  stopProcessingRules?: boolean;
+  markAsRead?: boolean;
+  forwardTo?: OutlookRecipient[];
+  markImportance?: "low" | "normal" | "high";
+}
+
+/** A mail rule for inbox message processing */
+export interface OutlookMessageRule {
+  id?: string;
+  displayName: string;
+  sequence: number;
+  isEnabled: boolean;
+  conditions?: OutlookMessageRulePredicates;
+  actions?: OutlookMessageRuleActions;
+}
+
+/** Response from listing mail rules */
+export interface OutlookMessageRuleListResponse {
+  value?: OutlookMessageRule[];
+}
+
+/** Automatic reply (out-of-office) settings */
+export interface OutlookAutoReplySettings {
+  status: "disabled" | "alwaysEnabled" | "scheduled";
+  externalAudience: "none" | "contactsOnly" | "all";
+  internalReplyMessage?: string;
+  externalReplyMessage?: string;
+  scheduledStartDateTime?: { dateTime: string; timeZone: string };
+  scheduledEndDateTime?: { dateTime: string; timeZone: string };
+}
+
+/** Mailbox settings containing automatic replies configuration */
+export interface OutlookMailboxSettings {
+  automaticRepliesSetting?: OutlookAutoReplySettings;
+}
+
+/** Delta query response with pagination support */
+export interface OutlookDeltaResponse<T> {
+  value?: T[];
+  "@odata.deltaLink"?: string;
+  "@odata.nextLink"?: string;
+}