@vellumai/assistant 0.8.2 → 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-server.ts

@@ -28,6 +28,8 @@ import {
 import { isHttpAuthDisabled } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
+import { createApprovalCopyGenerator } from "../daemon/approval-generators.js";
+import { createGuardianActionCopyGenerator } from "../daemon/guardian-action-generators.js";
 import { processMessage } from "../daemon/process-message.js";
 import { createLiveVoiceSession } from "../live-voice/live-voice-session.js";
 import { LiveVoiceSessionManager } from "../live-voice/live-voice-session-manager.js";
@@ -96,10 +98,8 @@ import { matchSkillRoute } from "./skill-route-registry.js";
 export { isPrivateAddress } from "./middleware/auth.js";
 
 import type {
-  ApprovalConversationGenerator,
   ApprovalCopyGenerator,
   GuardianActionCopyGenerator,
-  GuardianFollowUpConversationGenerator,
   RuntimeHttpServerOptions,
 } from "./http-types.js";
 
@@ -161,10 +161,8 @@ export class RuntimeHttpServer {
   private port: number;
   private hostname: string;
 
-  private approvalCopyGenerator?: ApprovalCopyGenerator;
-  private approvalConversationGenerator?: ApprovalConversationGenerator;
-  private guardianActionCopyGenerator?: GuardianActionCopyGenerator;
-  private guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator;
+  private readonly approvalCopyGenerator: ApprovalCopyGenerator;
+  private readonly guardianActionCopyGenerator: GuardianActionCopyGenerator;
   private retrySweepTimer: ReturnType<typeof setInterval> | null = null;
   private sweepInProgress = false;
 
@@ -175,11 +173,8 @@ export class RuntimeHttpServer {
     this.port = options.port ?? DEFAULT_PORT;
     this.hostname = options.hostname ?? DEFAULT_HOSTNAME;
 
-    this.approvalCopyGenerator = options.approvalCopyGenerator;
-    this.approvalConversationGenerator = options.approvalConversationGenerator;
-    this.guardianActionCopyGenerator = options.guardianActionCopyGenerator;
-    this.guardianFollowUpConversationGenerator =
-      options.guardianFollowUpConversationGenerator;
+    this.approvalCopyGenerator = createApprovalCopyGenerator();
+    this.guardianActionCopyGenerator = createGuardianActionCopyGenerator();
     this.liveVoiceSessionManager = new LiveVoiceSessionManager({
       createSession: (context) => createLiveVoiceSession(context),
     });
@@ -560,11 +555,7 @@ export class RuntimeHttpServer {
       const endpoint = url.pathname.slice("/v1/".length).replace(/\/$/, "");
       meta = this.router.findLoggingMetadata(req.method, endpoint) ?? undefined;
     }
-    return withRequestLogging(
-      req,
-      () => this.routeRequest(req, server),
-      meta,
-    );
+    return withRequestLogging(req, () => this.routeRequest(req, server), meta);
   }
 
   private async routeRequest(

package/src/runtime/http-types.ts

@@ -14,10 +14,6 @@ import type {
 export type { SlackInboundMessageMetadata };
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { AssistantEventHub } from "./assistant-event-hub.js";
-import type {
-  ApprovalCopyGenerator,
-  GuardianActionCopyGenerator,
-} from "./message-composer-types.js";
 
 export type {
   ApprovalCopyGenerator,
@@ -61,47 +57,13 @@ export type ApprovalConversationGenerator = (
   context: ApprovalConversationContext,
 ) => Promise<ApprovalConversationResult>;
 
-// ---------------------------------------------------------------------------
-// Guardian follow-up conversation flow types
-// ---------------------------------------------------------------------------
-
-/** The disposition returned by the guardian follow-up conversation engine. */
-export type GuardianFollowUpDisposition =
-  | "call_back"
-  | "decline"
-  | "keep_pending";
-
-/** Structured result from a single turn of the guardian follow-up conversation. */
-export interface GuardianFollowUpTurnResult {
-  disposition: GuardianFollowUpDisposition;
-  replyText: string;
-}
-
-/** Input context for the guardian follow-up conversation engine. */
-export interface GuardianFollowUpConversationContext {
-  /** The original question that was asked during the voice call. */
-  questionText: string;
-  /** The guardian's late answer text that initiated the follow-up. */
-  lateAnswerText: string;
-  /** The guardian's latest reply in the follow-up conversation. */
-  guardianReply: string;
-}
-
-/**
- * Daemon-injected function that processes one turn of a guardian follow-up
- * conversation. Classifies the guardian's intent into a structured disposition
- * and produces a natural reply.
- */
-export type GuardianFollowUpConversationGenerator = (
-  context: GuardianFollowUpConversationContext,
-) => Promise<GuardianFollowUpTurnResult>;
-
 export interface RuntimeMessageConversationOptions {
   transport?: {
     channelId: ChannelId;
     hints?: string[];
     uxBrief?: string;
     chatType?: string;
+    clientTimezone?: string;
   };
   assistantId?: string;
   trustContext?: TrustContext;
@@ -113,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`.
@@ -145,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.
@@ -173,14 +133,6 @@ export interface RuntimeHttpServerOptions {
   port?: number;
   /** Hostname / IP to bind to. Defaults to '127.0.0.1' (loopback-only). */
   hostname?: string;
-  /** Daemon-injected generator for approval copy (provider-backed). */
-  approvalCopyGenerator?: ApprovalCopyGenerator;
-  /** Daemon-injected generator for conversational approval flow (provider-backed). */
-  approvalConversationGenerator?: ApprovalConversationGenerator;
-  /** Daemon-injected generator for guardian action copy (provider-backed). */
-  guardianActionCopyGenerator?: GuardianActionCopyGenerator;
-  /** Daemon-injected generator for guardian follow-up conversation (provider-backed). */
-  guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator;
 }
 
 export interface RuntimeAttachmentMetadata {
@@ -214,7 +166,6 @@ export interface RuntimeMessagePayload {
     approvalReason?: string;
     riskThreshold?: string;
   }>;
-  interfaces?: string[];
   surfaces?: Array<{
     surfaceId: string;
     surfaceType: string;
@@ -236,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;