@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -141,6 +141,29 @@ export async function deliverRenderedReplyViaCallback(
     return;
   }
 
+  if (startFromSegment >= deliverableSegments.length) {
+    if (replyAttachments) {
+      const result: ChannelDeliveryResult = await deliverChannelReply(
+        callbackUrl,
+        {
+          chatId,
+          attachments: replyAttachments,
+          assistantId,
+          ephemeral,
+          user,
+          messageTs,
+        },
+      );
+      const deliveredTs = result.ts ?? messageTs;
+      if (deliveredTs) {
+        onMessageTs?.(deliveredTs);
+      }
+    } else if (messageTs) {
+      onMessageTs?.(messageTs);
+    }
+    return;
+  }
+
   const isSlack = isSlackCallbackUrl(callbackUrl);
 
   // Only the first segment uses messageTs for in-place update;

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

@@ -11,7 +11,11 @@ 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 {
+  addSlackDmLiveDeliveredTextResponseIndex,
+  getSlackDmLiveDeliveredTextResponseIndexes,
+  updateDeliveredSegmentCount,
+} from "../memory/delivery-channels.js";
 import {
   clearPayload,
   linkMessage,
@@ -33,6 +37,7 @@ import {
 } from "./channel-reply-delivery.js";
 import { deliverChannelReply } from "./gateway-client.js";
 import type { MessageProcessor } from "./http-types.js";
+import { createSlackDmTextDeliveryController } from "./slack-dm-text-delivery.js";
 import { resolveRoutingStateFromRuntime } from "./trust-context-resolver.js";
 
 const log = getLogger("runtime-http");
@@ -258,6 +263,27 @@ export async function sweepFailedEvents(
       sourceMetadata.chatType.trim().length > 0
         ? sourceMetadata.chatType.trim()
         : undefined;
+    const replyCallbackUrl =
+      typeof payload.replyCallbackUrl === "string"
+        ? payload.replyCallbackUrl
+        : undefined;
+    const externalChatId =
+      typeof payload.externalChatId === "string"
+        ? payload.externalChatId
+        : undefined;
+    const slackDmTextDelivery = externalChatId
+      ? createSlackDmTextDeliveryController({
+          sourceChannel,
+          chatType: metadataChatType,
+          replyCallbackUrl,
+          chatId: externalChatId,
+          assistantId,
+          deliveredTextResponseIndexes:
+            getSlackDmLiveDeliveredTextResponseIndexes(event.id),
+          onTextResponseDelivered: (responseIndex) =>
+            addSlackDmLiveDeliveredTextResponseIndex(event.id, responseIndex),
+        })
+      : undefined;
     let replyMessageId: string | undefined;
     const observeAgentEvent = (msg: ServerMessage): void => {
       if (
@@ -267,6 +293,7 @@ export async function sweepFailedEvents(
       ) {
         replyMessageId = msg.messageId;
       }
+      slackDmTextDelivery?.observeEvent(msg);
     };
 
     let userMessageId: string | undefined;
@@ -304,26 +331,29 @@ export async function sweepFailedEvents(
       );
     } catch (err) {
       log.error({ err, eventId: event.id }, "Retry failed for channel event");
+      if (slackDmTextDelivery) {
+        await slackDmTextDelivery.waitForPendingDeliveries();
+      }
       recordProcessingFailure(event.id, err);
       continue;
     }
 
-    const replyCallbackUrl =
-      typeof payload.replyCallbackUrl === "string"
-        ? payload.replyCallbackUrl
-        : undefined;
     if (replyCallbackUrl) {
-      const externalChatId =
-        typeof payload.externalChatId === "string"
-          ? payload.externalChatId
-          : undefined;
       if (externalChatId) {
         try {
+          if (slackDmTextDelivery) {
+            await slackDmTextDelivery.waitForPendingDeliveries();
+          }
           // 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
-          // new response.
-          updateDeliveredSegmentCount(event.id, 0);
+          // previously tracked final-delivery progress belongs to the old
+          // response and must not carry over. Use live Slack DM progress as
+          // the new baseline before final delivery so delivery-only retries do
+          // not duplicate text if the callback fails before reporting progress.
+          const liveDeliveryResumeOptions =
+            slackDmTextDelivery?.getFinalDeliveryResumeOptions(replyMessageId);
+          const finalDeliveryStartFromSegment =
+            liveDeliveryResumeOptions?.startFromSegment ?? 0;
+          updateDeliveredSegmentCount(event.id, finalDeliveryStartFromSegment);
           await deliverReplyViaCallback(
             event.conversationId,
             externalChatId,
@@ -332,7 +362,10 @@ export async function sweepFailedEvents(
             {
               messageId: replyMessageId,
               sinceMessageId: userMessageId,
-              startFromSegment: 0,
+              startFromSegment: finalDeliveryStartFromSegment,
+              ...(liveDeliveryResumeOptions?.messageTs
+                ? { messageTs: liveDeliveryResumeOptions.messageTs }
+                : {}),
               onSegmentDelivered: (count) =>
                 updateDeliveredSegmentCount(event.id, count),
             },

package/src/runtime/confirmation-request-guardian-bridge.ts

@@ -12,7 +12,6 @@
  * canonical records.
  */
 
-
 import type { TrustContext } from "../daemon/trust-context.js";
 import {
   type CanonicalGuardianRequest,
@@ -150,6 +149,7 @@ export function bridgeConfirmationRequestToGuardian(
     sourceEventName: "guardian.question",
     sourceChannel: sourceChannel as NotificationSourceChannel,
     sourceContextId: conversationId,
+    requiresConversation: true,
     attentionHints: {
       requiresAction: true,
       urgency: "high",

package/src/runtime/http-types.ts

@@ -148,8 +148,6 @@ export interface RuntimeAttachmentMetadata {
 
 export interface RuntimeMessagePayload {
   id: string;
-  /** Concrete persisted assistant row id for row-scoped actions. */
-  daemonMessageId?: string;
   role: string;
   content: string;
   timestamp: string;

package/src/runtime/migrations/vbundle-builder.ts

@@ -679,10 +679,16 @@ export interface BuildExportVBundleOptions {
    * Optional callback to checkpoint the WAL before reading the database file.
    * In WAL mode, committed rows may live in the -wal file and not yet be
    * flushed to the main .db file. Callers should pass a function that runs
-   * PRAGMA wal_checkpoint(TRUNCATE) on the live database connection.
+   * PRAGMA wal_checkpoint(FULL) on the live database connection. (Not
+   * TRUNCATE — see assistant/AGENTS.md "SQLite WAL checkpointing".)
    * Called before the workspace walk so the DB file is up to date.
+   *
+   * May return a Promise — `streamExportVBundle` awaits the result so an
+   * async-dispatched checkpoint (e.g. via `runAsyncSqlite`) does not race
+   * with the file walk. The synchronous `buildExportVBundle` path does
+   * not await; pass a sync callback there.
    */
-  checkpoint?: () => void;
+  checkpoint?: () => void | Promise<void>;
   /** Optional credential entries to include in the archive under credentials/ prefix. */
   credentials?: Array<{ account: string; value: string }>;
 }
@@ -1120,9 +1126,11 @@ export async function streamExportVBundle(
     credentials,
   } = options;
 
-  // Flush WAL to the main database file before reading
+  // Flush WAL to the main database file before reading. Awaiting allows
+  // the callback to dispatch the checkpoint via `runAsyncSqlite` so the
+  // daemon event loop stays responsive while SQLite flushes the WAL.
   if (checkpoint) {
-    checkpoint();
+    await checkpoint();
   }
 
   const allFileMetadata: FileMetadata[] = [];

package/src/runtime/pending-interactions.ts

@@ -143,7 +143,6 @@ function emitResolved(
     type: "interaction_resolved",
     requestId,
     conversationId: interaction.conversationId,
-    conversationKey: interaction.conversationId,
     kind: interaction.kind,
     state,
   });

package/src/runtime/routes/__tests__/bookmark-routes.test.ts

@@ -22,6 +22,7 @@ mock.module("../../assistant-event-hub.js", () => ({
     },
     subscribe: () => () => {},
   },
+  broadcastMessage: async () => {},
 }));
 
 import { getDb } from "../../../memory/db-connection.js";

package/src/runtime/routes/__tests__/conversation-compaction-routes.test.ts

@@ -0,0 +1,406 @@
+/**
+ * Tests for the compaction-trail route + projection.
+ *
+ * The handler is exercised against a fake `LlmRequestLogSource` so we
+ * can pin (a) the BadRequestError / NotFoundError branches that don't
+ * involve any logs, and (b) the happy path that returns a projected
+ * trail with the expected shape. The projection function is unit-tested
+ * directly so its branches stay covered even if the handler ever swaps
+ * to a different log source.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+    llmRequestLogs: { readSource: "local" as const },
+  }),
+}));
+
+// ---------------------------------------------------------------------
+// Source + conversation-crud module mocks
+// ---------------------------------------------------------------------
+
+import type { LogRow } from "../../../memory/llm-request-log-store.js";
+
+interface FakeSourceState {
+  conversation: { id: string } | null;
+  selectedCall: LogRow | null;
+  previousNonCompactionCallCreatedAt: number | null;
+  compactionLogs: LogRow[];
+}
+
+const state: FakeSourceState = {
+  conversation: null,
+  selectedCall: null,
+  previousNonCompactionCallCreatedAt: null,
+  compactionLogs: [],
+};
+
+// Records the inputs the handler passed to the source so tests can
+// pin the windowing plumbing without relying on the projection.
+const sourceCalls = {
+  getRequestLogByIdArgs: [] as string[],
+  getPreviousNonCompactionCallCreatedAtArgs: [] as Array<{
+    conversationId: string;
+    beforeCreatedAt: number;
+  }>,
+  getCompactionLogsBetweenArgs: [] as Array<{
+    conversationId: string;
+    afterCreatedAt: number | null;
+    beforeCreatedAt: number;
+  }>,
+};
+
+mock.module("../../../memory/conversation-crud.js", () => ({
+  getConversation: (id: string) =>
+    state.conversation && state.conversation.id === id
+      ? state.conversation
+      : null,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../../../memory/llm-request-log-source.js", () => ({
+  getLlmRequestLogSource: async () => ({
+    getRequestLogById: async (id: string) => {
+      sourceCalls.getRequestLogByIdArgs.push(id);
+      return state.selectedCall;
+    },
+    getRequestLogsByMessageId: async () => [],
+    getRequestLogsByConversationId: async () => [],
+    getPreviousNonCompactionCallCreatedAt: async (
+      conversationId: string,
+      beforeCreatedAt: number,
+    ) => {
+      sourceCalls.getPreviousNonCompactionCallCreatedAtArgs.push({
+        conversationId,
+        beforeCreatedAt,
+      });
+      return state.previousNonCompactionCallCreatedAt;
+    },
+    getCompactionLogsBetween: async (
+      conversationId: string,
+      afterCreatedAt: number | null,
+      beforeCreatedAt: number,
+    ) => {
+      sourceCalls.getCompactionLogsBetweenArgs.push({
+        conversationId,
+        afterCreatedAt,
+        beforeCreatedAt,
+      });
+      return state.compactionLogs;
+    },
+  }),
+}));
+
+// Imported AFTER the mocks so the handler picks up the fakes.
+import { projectLogRowToCompactionTrailEvent,ROUTES } from "../conversation-compaction-routes.js";
+import { BadRequestError, NotFoundError } from "../errors.js";
+
+const route = ROUTES.find(
+  (r) => r.operationId === "conversations_compaction_trail_get",
+)!;
+const handler = route.handler as (
+  args: Record<string, unknown>,
+) => Promise<{ conversationId: string; events: unknown[] }>;
+
+function fakeLogRow(overrides: Partial<LogRow> = {}): LogRow {
+  return {
+    id: "log-default",
+    conversationId: "conv-default",
+    messageId: null,
+    provider: "anthropic",
+    requestPayload: "{}",
+    responsePayload: "{}",
+    createdAt: 1000,
+    agentLoopExitReason: null,
+    callSite: null,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  state.conversation = null;
+  state.selectedCall = null;
+  state.previousNonCompactionCallCreatedAt = null;
+  state.compactionLogs = [];
+  sourceCalls.getRequestLogByIdArgs.length = 0;
+  sourceCalls.getPreviousNonCompactionCallCreatedAtArgs.length = 0;
+  sourceCalls.getCompactionLogsBetweenArgs.length = 0;
+});
+
+// ---------------------------------------------------------------------
+// Route registration sanity
+// ---------------------------------------------------------------------
+
+describe("conversation-compaction-routes — registration", () => {
+  test("exposes one GET route at conversations/:id/compaction", () => {
+    expect(route).toBeDefined();
+    expect(route.method).toBe("GET");
+    expect(route.endpoint).toBe("conversations/:id/compaction");
+    expect(route.policyKey).toBe("conversations/compaction");
+  });
+});
+
+// ---------------------------------------------------------------------
+// Handler — error branches
+// ---------------------------------------------------------------------
+
+describe("handleGetCompactionTrail — request-shape errors", () => {
+  test("throws BadRequestError when the conversation id path param is missing", async () => {
+    await expect(
+      handler({ pathParams: {}, queryParams: { callId: "call-1" } }),
+    ).rejects.toThrow(BadRequestError);
+  });
+
+  test("throws BadRequestError when the callId query param is missing", async () => {
+    state.conversation = { id: "conv-1" };
+    await expect(
+      handler({ pathParams: { id: "conv-1" }, queryParams: {} }),
+    ).rejects.toThrow(BadRequestError);
+  });
+
+  test("throws NotFoundError when the conversation does not exist", async () => {
+    state.conversation = null;
+    await expect(
+      handler({
+        pathParams: { id: "missing" },
+        queryParams: { callId: "call-1" },
+      }),
+    ).rejects.toThrow(NotFoundError);
+  });
+
+  test("throws NotFoundError when the referenced LLM call does not exist", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = null;
+    await expect(
+      handler({
+        pathParams: { id: "conv-1" },
+        queryParams: { callId: "missing-call" },
+      }),
+    ).rejects.toThrow(NotFoundError);
+  });
+
+  test("throws BadRequestError when callId belongs to a different conversation", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-x",
+      conversationId: "conv-other",
+      createdAt: 1234,
+    });
+    await expect(
+      handler({
+        pathParams: { id: "conv-1" },
+        queryParams: { callId: "call-x" },
+      }),
+    ).rejects.toThrow(BadRequestError);
+  });
+});
+
+// ---------------------------------------------------------------------
+// Handler — happy path
+// ---------------------------------------------------------------------
+
+describe("handleGetCompactionTrail — happy path", () => {
+  test("forwards both window bounds to the source (prior call as floor, selected call as ceiling)", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-selected",
+      conversationId: "conv-1",
+      createdAt: 5000,
+    });
+    state.previousNonCompactionCallCreatedAt = 2000;
+    state.compactionLogs = [];
+
+    await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-selected" },
+    });
+
+    expect(sourceCalls.getRequestLogByIdArgs).toEqual(["call-selected"]);
+    expect(sourceCalls.getPreviousNonCompactionCallCreatedAtArgs).toEqual([
+      { conversationId: "conv-1", beforeCreatedAt: 5000 },
+    ]);
+    expect(sourceCalls.getCompactionLogsBetweenArgs).toEqual([
+      { conversationId: "conv-1", afterCreatedAt: 2000, beforeCreatedAt: 5000 },
+    ]);
+  });
+
+  test("passes a null floor when the selected call is the first real call in the conversation", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-first",
+      conversationId: "conv-1",
+      createdAt: 5000,
+    });
+    state.previousNonCompactionCallCreatedAt = null;
+    state.compactionLogs = [];
+
+    await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-first" },
+    });
+
+    expect(sourceCalls.getCompactionLogsBetweenArgs).toEqual([
+      { conversationId: "conv-1", afterCreatedAt: null, beforeCreatedAt: 5000 },
+    ]);
+  });
+
+  test("returns an empty events list when no compactions ran in the window", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-1",
+      conversationId: "conv-1",
+      createdAt: 5000,
+    });
+    state.previousNonCompactionCallCreatedAt = 2000;
+    state.compactionLogs = [];
+
+    const result = await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-1" },
+    });
+    expect(result).toEqual({ conversationId: "conv-1", events: [] });
+  });
+
+  test("projects each compaction log to the wire shape", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-1",
+      conversationId: "conv-1",
+      createdAt: 9000,
+    });
+    state.previousNonCompactionCallCreatedAt = 500;
+    state.compactionLogs = [
+      fakeLogRow({
+        id: "compaction-1",
+        conversationId: "conv-1",
+        createdAt: 1000,
+      }),
+      fakeLogRow({
+        id: "compaction-2",
+        conversationId: "conv-1",
+        createdAt: 2000,
+      }),
+    ];
+
+    const result = await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-1" },
+    });
+
+    expect(result.conversationId).toBe("conv-1");
+    expect(result.events).toHaveLength(2);
+    // Field-set check on the first event — values are validated by the
+    // projection tests below; here we just confirm the route emits the
+    // full wire shape.
+    expect(Object.keys((result.events[0] as object)).sort()).toEqual([
+      "createdAt",
+      "durationMs",
+      "estimatedCostUsd",
+      "id",
+      "inputTokens",
+      "model",
+      "outputTokens",
+      "provider",
+      "requestMessageCount",
+      "responsePreview",
+      "stopReason",
+    ]);
+  });
+});
+
+// ---------------------------------------------------------------------
+// Projection unit tests
+// ---------------------------------------------------------------------
+
+describe("projectLogRowToCompactionTrailEvent", () => {
+  test("returns null for every summary-derived field when payloads are empty", () => {
+    const event = projectLogRowToCompactionTrailEvent(fakeLogRow());
+    expect(event.id).toBe("log-default");
+    expect(event.createdAt).toBe(1000);
+    expect(event.model).toBeNull();
+    expect(event.inputTokens).toBeNull();
+    expect(event.outputTokens).toBeNull();
+    expect(event.responsePreview).toBeNull();
+    expect(event.requestMessageCount).toBeNull();
+    expect(event.stopReason).toBeNull();
+    expect(event.estimatedCostUsd).toBeNull();
+  });
+
+  test("always returns null for durationMs (column not yet recorded)", () => {
+    // Even if a future payload shape carries duration info, the
+    // projection deliberately drops it — the gap is what surfaces to
+    // the UI as "Unavailable" and informs the data-model decision.
+    const event = projectLogRowToCompactionTrailEvent(
+      fakeLogRow({
+        responsePayload: JSON.stringify({
+          // A made-up shape with a duration value to confirm the
+          // projection ignores it.
+          durationMs: 1234,
+          duration_ms: 1234,
+        }),
+      }),
+    );
+    expect(event.durationMs).toBeNull();
+  });
+
+  test("falls back to the stored provider when the normalizer can't infer one", () => {
+    // Empty payloads => normalizer returns no summary => fallback to
+    // the row's stored `provider` column.
+    const event = projectLogRowToCompactionTrailEvent(
+      fakeLogRow({ provider: "anthropic" }),
+    );
+    expect(event.provider).toBe("anthropic");
+  });
+
+  test("extracts model + inputTokens + stopReason from a real Anthropic payload", () => {
+    const event = projectLogRowToCompactionTrailEvent(
+      fakeLogRow({
+        provider: "anthropic",
+        requestPayload: JSON.stringify({
+          model: "claude-sonnet-4-5",
+          messages: [{ role: "user", content: "Summarize the prior context." }],
+        }),
+        responsePayload: JSON.stringify({
+          type: "message",
+          model: "claude-sonnet-4-5",
+          role: "assistant",
+          content: [{ type: "text", text: "Summary text…" }],
+          stop_reason: "end_turn",
+          usage: { input_tokens: 12_000, output_tokens: 800 },
+        }),
+      }),
+    );
+    expect(event.model).toBe("claude-sonnet-4-5");
+    expect(event.provider).toBe("anthropic");
+    expect(event.inputTokens).toBe(12_000);
+    expect(event.outputTokens).toBe(800);
+    expect(event.stopReason).toBe("end_turn");
+  });
+
+  test("tolerates non-JSON payloads without throwing (falls back to nulls)", () => {
+    const event = projectLogRowToCompactionTrailEvent(
+      fakeLogRow({
+        requestPayload: "not-json{{{",
+        responsePayload: "<html>nope</html>",
+      }),
+    );
+    expect(event.id).toBe("log-default");
+    expect(event.model).toBeNull();
+    expect(event.inputTokens).toBeNull();
+  });
+});