@vellumai/assistant 0.8.3 → 0.8.4

package/src/runtime/channel-reply-delivery.ts

@@ -1,3 +1,4 @@
+import type { RenderedHistoryContent } from "../daemon/handlers/shared.js";
 import { renderHistoryContent } from "../daemon/handlers/shared.js";
 import { getAttachmentMetadataForMessage } from "../memory/attachments-store.js";
 import {
@@ -76,6 +77,18 @@ function toDeliverableTextSegments(
   return [];
 }
 
+function hasDeliverableReply(
+  rendered: RenderedHistoryContent,
+  attachments: RuntimeAttachmentMetadata[],
+): boolean {
+  return (
+    toDeliverableTextSegments(rendered.textSegments, rendered.text).length >
+      0 ||
+    attachments.length > 0 ||
+    hasNoResponseMarker(rendered.textSegments)
+  );
+}
+
 export async function deliverRenderedReplyViaCallback(
   params: DeliverRenderedReplyParams,
 ): Promise<void> {
@@ -169,6 +182,13 @@ export async function deliverRenderedReplyViaCallback(
 }
 
 export type DeliverReplyOptions = {
+  /** Persisted assistant message row to deliver; defaults to latest assistant. */
+  messageId?: string;
+  /**
+   * Internal conversation message id for the user row that started this
+   * delivery. When set, fallback scans never cross into older turns.
+   */
+  sinceMessageId?: string;
   startFromSegment?: number;
   onSegmentDelivered?: (deliveredCount: number) => void;
   /** Deliver as ephemeral (visible only to `user`). Fire-and-forget. */
@@ -181,6 +201,125 @@ export type DeliverReplyOptions = {
   onMessageTs?: (ts: string) => void;
 };
 
+type PersistedMessage = ReturnType<typeof getMessages>[number];
+
+function readPersistedAssistantReply(msg: PersistedMessage): {
+  rendered: RenderedHistoryContent;
+  replyAttachments: RuntimeAttachmentMetadata[];
+} {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(msg.content);
+  } catch {
+    parsed = msg.content;
+  }
+  const rendered = renderHistoryContent(parsed);
+
+  const linked = getAttachmentMetadataForMessage(msg.id);
+  const replyAttachments: RuntimeAttachmentMetadata[] = linked.map((a) => ({
+    id: a.id,
+    filename: a.originalFilename,
+    mimeType: a.mimeType,
+    sizeBytes: a.sizeBytes,
+    kind: a.kind,
+  }));
+
+  return { rendered, replyAttachments };
+}
+
+function isToolResultUserMessage(msg: PersistedMessage): boolean {
+  if (msg.role !== "user") return false;
+  try {
+    const parsed = JSON.parse(msg.content) as unknown;
+    return (
+      Array.isArray(parsed) &&
+      parsed.length > 0 &&
+      parsed.every(
+        (block) =>
+          block !== null &&
+          typeof block === "object" &&
+          (block as Record<string, unknown>).type === "tool_result",
+      )
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function findAssistantReplyMessageIdForTurn(
+  conversationId: string,
+  userMessageId: string,
+): string | undefined {
+  const msgs = getMessages(conversationId);
+  const userIndex = msgs.findIndex((msg) => msg.id === userMessageId);
+  if (userIndex === -1) return undefined;
+
+  let turnEndIndex = msgs.length;
+  for (let i = userIndex + 1; i < msgs.length; i++) {
+    const msg = msgs[i];
+    if (msg.role === "user" && !isToolResultUserMessage(msg)) {
+      turnEndIndex = i;
+      break;
+    }
+  }
+
+  for (let i = turnEndIndex - 1; i > userIndex; i--) {
+    const msg = msgs[i];
+    if (msg.role === "assistant") {
+      const { rendered, replyAttachments } = readPersistedAssistantReply(msg);
+      if (hasDeliverableReply(rendered, replyAttachments)) {
+        return msg.id;
+      }
+    }
+  }
+  return undefined;
+}
+
+async function deliverPersistedAssistantMessageViaCallback(
+  msg: PersistedMessage,
+  externalChatId: string,
+  callbackUrl: string,
+  assistantId: string | undefined,
+  options: DeliverReplyOptions | undefined,
+): Promise<boolean> {
+  const { rendered, replyAttachments } = readPersistedAssistantReply(msg);
+  if (!hasDeliverableReply(rendered, replyAttachments)) {
+    return false;
+  }
+
+  // Compose an `onMessageTs` that reconciles `slackMeta.channelTs` on the
+  // persisted assistant row once Slack returns the authoritative ts. The
+  // assistant row was written BEFORE the gateway POST in
+  // `handleMessageComplete`, so the partial `slackMeta` it carries is
+  // missing `channelTs` and would otherwise be rejected by
+  // `readSlackMetadata`, dropping the row out of chronological/thread-tag
+  // rendering. We only act on the FIRST ts (top-level segment); any
+  // subsequent split segments become independent Slack messages with
+  // their own ts and are not represented as separate DB rows.
+  const reconcileOnMessageTs = makeChannelTsReconciler(msg.id);
+  const callerOnMessageTs = options?.onMessageTs;
+  const composedOnMessageTs = (ts: string): void => {
+    reconcileOnMessageTs(ts);
+    callerOnMessageTs?.(ts);
+  };
+
+  await deliverRenderedReplyViaCallback({
+    callbackUrl,
+    chatId: externalChatId,
+    textSegments: rendered.textSegments,
+    fallbackText: rendered.text,
+    attachments: replyAttachments,
+    assistantId,
+    startFromSegment: options?.startFromSegment,
+    onSegmentDelivered: options?.onSegmentDelivered,
+    ephemeral: options?.ephemeral,
+    user: options?.user,
+    messageTs: options?.messageTs,
+    onMessageTs: composedOnMessageTs,
+  });
+  return true;
+}
+
 export async function deliverReplyViaCallback(
   conversationId: string,
   externalChatId: string,
@@ -188,58 +327,54 @@ export async function deliverReplyViaCallback(
   assistantId?: string,
   options?: DeliverReplyOptions,
 ): Promise<void> {
+  if (options?.messageId) {
+    const msg = getMessageById(options.messageId, conversationId);
+    if (!msg || msg.role !== "assistant") {
+      throw new Error(
+        `Target assistant reply message not found: ${options.messageId}`,
+      );
+    }
+    await deliverPersistedAssistantMessageViaCallback(
+      msg,
+      externalChatId,
+      callbackUrl,
+      assistantId,
+      options,
+    );
+    return;
+  }
+
+  if (options?.sinceMessageId) {
+    const replyMessageId = findAssistantReplyMessageIdForTurn(
+      conversationId,
+      options.sinceMessageId,
+    );
+    if (replyMessageId) {
+      const msg = getMessageById(replyMessageId, conversationId);
+      if (msg && msg.role === "assistant") {
+        await deliverPersistedAssistantMessageViaCallback(
+          msg,
+          externalChatId,
+          callbackUrl,
+          assistantId,
+          options,
+        );
+      }
+    }
+    return;
+  }
+
   const msgs = getMessages(conversationId);
   for (let i = msgs.length - 1; i >= 0; i--) {
     if (msgs[i].role !== "assistant") continue;
-
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(msgs[i].content);
-    } catch {
-      parsed = msgs[i].content;
-    }
-    const rendered = renderHistoryContent(parsed);
-
-    const linked = getAttachmentMetadataForMessage(msgs[i].id);
-    const replyAttachments: RuntimeAttachmentMetadata[] = linked.map((a) => ({
-      id: a.id,
-      filename: a.originalFilename,
-      mimeType: a.mimeType,
-      sizeBytes: a.sizeBytes,
-      kind: a.kind,
-    }));
-
-    // Compose an `onMessageTs` that reconciles `slackMeta.channelTs` on the
-    // persisted assistant row once Slack returns the authoritative ts. The
-    // assistant row was written BEFORE the gateway POST in
-    // `handleMessageComplete`, so the partial `slackMeta` it carries is
-    // missing `channelTs` and would otherwise be rejected by
-    // `readSlackMetadata`, dropping the row out of chronological/thread-tag
-    // rendering. We only act on the FIRST ts (top-level segment); any
-    // subsequent split segments become independent Slack messages with
-    // their own ts and are not represented as separate DB rows.
-    const reconcileOnMessageTs = makeChannelTsReconciler(msgs[i].id);
-    const callerOnMessageTs = options?.onMessageTs;
-    const composedOnMessageTs = (ts: string): void => {
-      reconcileOnMessageTs(ts);
-      callerOnMessageTs?.(ts);
-    };
-
-    await deliverRenderedReplyViaCallback({
+    const delivered = await deliverPersistedAssistantMessageViaCallback(
+      msgs[i],
+      externalChatId,
       callbackUrl,
-      chatId: externalChatId,
-      textSegments: rendered.textSegments,
-      fallbackText: rendered.text,
-      attachments: replyAttachments,
       assistantId,
-      startFromSegment: options?.startFromSegment,
-      onSegmentDelivered: options?.onSegmentDelivered,
-      ephemeral: options?.ephemeral,
-      user: options?.user,
-      messageTs: options?.messageTs,
-      onMessageTs: composedOnMessageTs,
-    });
-    break;
+      options,
+    );
+    if (delivered) break;
   }
 }
 

package/src/runtime/channel-retry-sweep.ts

@@ -9,17 +9,28 @@ import {
 } from "../channels/types.js";
 import { getDiskPressureStatus } from "../daemon/disk-pressure-guard.js";
 import { classifyDiskPressureTurnPolicy } from "../daemon/disk-pressure-policy.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { updateDeliveredSegmentCount } from "../memory/delivery-channels.js";
-import { clearPayload, linkMessage } from "../memory/delivery-crud.js";
 import {
+  clearPayload,
+  linkMessage,
+  storeReplyMessageId,
+} from "../memory/delivery-crud.js";
+import {
+  getRetryableDeliveryEvents,
   getRetryableEvents,
+  markDeliveryDelivered,
   markProcessed,
   markRetryableFailure,
+  recordDeliveryFailure,
   recordProcessingFailure,
 } from "../memory/delivery-status.js";
 import { getLogger } from "../util/logger.js";
-import { deliverReplyViaCallback } from "./channel-reply-delivery.js";
+import {
+  deliverReplyViaCallback,
+  findAssistantReplyMessageIdForTurn,
+} from "./channel-reply-delivery.js";
 import { deliverChannelReply } from "./gateway-client.js";
 import type { MessageProcessor } from "./http-types.js";
 import { resolveRoutingStateFromRuntime } from "./trust-context-resolver.js";
@@ -91,9 +102,13 @@ export async function sweepFailedEvents(
   processMessage: MessageProcessor,
 ): Promise<void> {
   const events = getRetryableEvents();
-  if (events.length === 0) return;
+  const deliveryEvents = getRetryableDeliveryEvents();
+  if (events.length === 0 && deliveryEvents.length === 0) return;
 
-  log.info({ count: events.length }, "Retrying failed channel inbound events");
+  log.info(
+    { processingCount: events.length, deliveryCount: deliveryEvents.length },
+    "Retrying failed channel inbound events",
+  );
 
   for (const event of events) {
     if (!event.rawPayload) {
@@ -243,9 +258,20 @@ export async function sweepFailedEvents(
       sourceMetadata.chatType.trim().length > 0
         ? sourceMetadata.chatType.trim()
         : undefined;
+    let replyMessageId: string | undefined;
+    const observeAgentEvent = (msg: ServerMessage): void => {
+      if (
+        msg.type === "message_complete" &&
+        (msg.source === undefined || msg.source === "main") &&
+        typeof msg.messageId === "string"
+      ) {
+        replyMessageId = msg.messageId;
+      }
+    };
 
+    let userMessageId: string | undefined;
     try {
-      const { messageId: userMessageId } = await processMessage(
+      const result = await processMessage(
         event.conversationId,
         content,
         attachmentIds,
@@ -260,27 +286,39 @@ export async function sweepFailedEvents(
           trustContext,
           isInteractive:
             resolveRoutingStateFromRuntime(trustContext).promptWaitingAllowed,
+          onEvent: observeAgentEvent,
         },
         sourceChannel,
         sourceInterface,
       );
+      userMessageId = result.messageId;
       linkMessage(event.id, userMessageId);
       markProcessed(event.id);
+      replyMessageId ??= result.assistantMessageId;
+      if (replyMessageId) {
+        storeReplyMessageId(event.id, replyMessageId);
+      }
       log.info(
         { eventId: event.id },
         "Successfully replayed failed channel event",
       );
+    } catch (err) {
+      log.error({ err, eventId: event.id }, "Retry failed for channel event");
+      recordProcessingFailure(event.id, err);
+      continue;
+    }
 
-      const replyCallbackUrl =
-        typeof payload.replyCallbackUrl === "string"
-          ? payload.replyCallbackUrl
+    const replyCallbackUrl =
+      typeof payload.replyCallbackUrl === "string"
+        ? payload.replyCallbackUrl
+        : undefined;
+    if (replyCallbackUrl) {
+      const externalChatId =
+        typeof payload.externalChatId === "string"
+          ? payload.externalChatId
           : undefined;
-      if (replyCallbackUrl) {
-        const externalChatId =
-          typeof payload.externalChatId === "string"
-            ? payload.externalChatId
-            : undefined;
-        if (externalChatId) {
+      if (externalChatId) {
+        try {
           // processMessage above generated a fresh assistant response, so any
           // previously tracked segment progress belongs to the old response and
           // must not carry over. Reset to 0 so we deliver all segments of the
@@ -292,16 +330,103 @@ export async function sweepFailedEvents(
             replyCallbackUrl,
             assistantId,
             {
+              messageId: replyMessageId,
+              sinceMessageId: userMessageId,
               startFromSegment: 0,
               onSegmentDelivered: (count) =>
                 updateDeliveredSegmentCount(event.id, count),
             },
           );
+          markDeliveryDelivered(event.id);
+        } catch (err) {
+          log.error(
+            { err, eventId: event.id },
+            "Retry delivery failed for channel event",
+          );
+          recordDeliveryFailure(event.id, err);
         }
       }
+    }
+  }
+
+  for (const event of deliveryEvents) {
+    if (!event.rawPayload) {
+      recordDeliveryFailure(
+        event.id,
+        new Error("No raw payload stored for delivery retry"),
+      );
+      continue;
+    }
+
+    let payload: Record<string, unknown>;
+    try {
+      payload = JSON.parse(event.rawPayload) as Record<string, unknown>;
+    } catch {
+      recordDeliveryFailure(
+        event.id,
+        new Error("Failed to parse stored raw payload for delivery retry"),
+      );
+      continue;
+    }
+
+    const replyCallbackUrl =
+      typeof payload.replyCallbackUrl === "string"
+        ? payload.replyCallbackUrl
+        : undefined;
+    const externalChatId =
+      typeof payload.externalChatId === "string"
+        ? payload.externalChatId
+        : undefined;
+    let replyMessageId =
+      typeof payload.replyMessageId === "string"
+        ? payload.replyMessageId
+        : undefined;
+    const assistantId =
+      typeof payload.assistantId === "string" ? payload.assistantId : undefined;
+    if (!replyCallbackUrl || !externalChatId) {
+      recordDeliveryFailure(
+        event.id,
+        new Error("Stored payload is missing delivery callback details"),
+      );
+      continue;
+    }
+    if (!replyMessageId && event.messageId) {
+      replyMessageId = findAssistantReplyMessageIdForTurn(
+        event.conversationId,
+        event.messageId,
+      );
+      if (replyMessageId) {
+        storeReplyMessageId(event.id, replyMessageId);
+      }
+    }
+    if (!replyMessageId) {
+      recordDeliveryFailure(
+        event.id,
+        new Error("Stored payload is missing assistant reply message id"),
+      );
+      continue;
+    }
+
+    try {
+      await deliverReplyViaCallback(
+        event.conversationId,
+        externalChatId,
+        replyCallbackUrl,
+        assistantId,
+        {
+          messageId: replyMessageId,
+          startFromSegment: event.deliveredSegmentCount,
+          onSegmentDelivered: (count) =>
+            updateDeliveredSegmentCount(event.id, count),
+        },
+      );
+      markDeliveryDelivered(event.id);
     } catch (err) {
-      log.error({ err, eventId: event.id }, "Retry failed for channel event");
-      recordProcessingFailure(event.id, err);
+      log.error(
+        { err, eventId: event.id },
+        "Retry delivery failed for processed channel event",
+      );
+      recordDeliveryFailure(event.id, err);
     }
   }
 }

package/src/runtime/http-types.ts

@@ -63,6 +63,7 @@ export interface RuntimeMessageConversationOptions {
     hints?: string[];
     uxBrief?: string;
     chatType?: string;
+    clientTimezone?: string;
   };
   assistantId?: string;
   trustContext?: TrustContext;
@@ -74,8 +75,6 @@ export interface RuntimeMessageConversationOptions {
   isInteractive?: boolean;
   /** Channel command intent metadata (e.g. Telegram /start). */
   commandIntent?: { type: string; payload?: string; languageCode?: string };
-  /** Slack-only non-persisted notice injected into the active model turn. */
-  slackRuntimeContextNotice?: string;
   /**
    * Persisted user-facing content. When present, storage/UI use this value
    * while the model-facing turn continues to use `content`.
@@ -106,7 +105,7 @@ export type MessageProcessor = (
   options?: RuntimeMessageConversationOptions,
   sourceChannel?: ChannelId,
   sourceInterface?: InterfaceId,
-) => Promise<{ messageId: string }>;
+) => Promise<{ messageId: string; assistantMessageId?: string }>;
 
 /**
  * Dependencies for the POST /v1/messages handler.
@@ -167,7 +166,6 @@ export interface RuntimeMessagePayload {
     approvalReason?: string;
     riskThreshold?: string;
   }>;
-  interfaces?: string[];
   surfaces?: Array<{
     surfaceId: string;
     surfaceType: string;
@@ -189,8 +187,13 @@ export interface RuntimeMessagePayload {
   };
   slackMessage?: {
     channelId: string;
+    channelName?: string;
     channelTs: string;
     threadTs?: string;
+    sender?: {
+      displayName?: string;
+      externalUserId?: string;
+    };
     messageLink?: {
       appUrl?: string;
       webUrl?: string;

package/src/runtime/pending-interactions.ts

@@ -18,7 +18,14 @@
  * resolve the interaction.
  */
 
+import type { InteractionResolutionState } from "../daemon/message-types/messages.js";
 import type { UserDecision } from "../permissions/types.js";
+import { getLogger } from "../util/logger.js";
+import { broadcastMessage } from "./assistant-event-hub.js";
+
+const log = getLogger("pending-interactions");
+
+export type { InteractionResolutionState } from "../daemon/message-types/messages.js";
 
 export interface ConfirmationDetails {
   toolName: string;
@@ -98,17 +105,50 @@ export function register(
  * Remove and return the pending interaction for the given requestId.
  * Auto-clears the proxy timer and detaches the abort listener if present.
  * Returns undefined if no interaction is registered.
+ *
+ * Emits `interaction_resolved` on the event hub when an interaction is
+ * actually removed (no-op when the entry was already consumed by another
+ * path). Callers pass `state` to communicate the lifecycle outcome
+ * — defaults to `"cancelled"`, the safest value when the call site has
+ * no extra context.
  */
-export function resolve(requestId: string): PendingInteraction | undefined {
+export function resolve(
+  requestId: string,
+  state: InteractionResolutionState = "cancelled",
+): PendingInteraction | undefined {
   const interaction = pending.get(requestId);
-  if (interaction) {
-    pending.delete(requestId);
-    if (interaction.timer != null) clearTimeout(interaction.timer);
-    interaction.detachAbort?.();
-  }
+  if (!interaction) return undefined;
+  pending.delete(requestId);
+  if (interaction.timer != null) clearTimeout(interaction.timer);
+  interaction.detachAbort?.();
+  emitResolved(requestId, interaction, state);
   return interaction;
 }
 
+function emitResolved(
+  requestId: string,
+  interaction: PendingInteraction,
+  state: InteractionResolutionState,
+): void {
+  log.info(
+    {
+      requestId,
+      conversationId: interaction.conversationId,
+      kind: interaction.kind,
+      state,
+    },
+    "Pending interaction resolved",
+  );
+  broadcastMessage({
+    type: "interaction_resolved",
+    requestId,
+    conversationId: interaction.conversationId,
+    conversationKey: interaction.conversationId,
+    kind: interaction.kind,
+    state,
+  });
+}
+
 /**
  * Return the pending interaction without removing it.
  * Used by trust-rule endpoint which doesn't resolve the confirmation itself.
@@ -146,7 +186,10 @@ export function getByConversation(
  * /v1/host-transfer-result after completing the operation, get a 404, and the
  * proxy timer would fire with a spurious timeout error.
  */
-export function removeByConversation(conversationId: string): void {
+export function removeByConversation(
+  conversationId: string,
+  state: InteractionResolutionState = "superseded",
+): void {
   // Snapshot keys to avoid mutation-during-iteration.
   for (const [requestId, interaction] of [...pending]) {
     if (
@@ -160,7 +203,7 @@ export function removeByConversation(conversationId: string): void {
       interaction.kind !== "acp_confirmation"
     ) {
       // resolve() clears the stored timer and detaches abort listeners.
-      resolve(requestId);
+      resolve(requestId, state);
     }
   }
 }