@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/config/seed-inference-profiles.ts

@@ -186,15 +186,29 @@ export function seedInferenceProfiles(
     }
   }
 
-  // Profile ordering — ensure all seeded profiles appear in the order array.
+  // Profile ordering: ensure all seeded profiles appear in the order array.
+  // A managed key absent from a workspace's order is placed next to the
+  // sibling that precedes it in the catalog rather than appended, so the
+  // managed profiles stay grouped in catalog order even on a workspace whose
+  // order already lists custom profiles. Entries already in the order keep
+  // their relative positions, so a user arrangement survives.
   const profileOrder = Array.isArray(llm.profileOrder)
     ? (llm.profileOrder as string[])
     : [];
-  const orderSet = new Set(profileOrder);
-  for (const name of Object.keys(MANAGED_PROFILE_TEMPLATES)) {
-    if (!orderSet.has(name)) {
+  const managedNames = Object.keys(MANAGED_PROFILE_TEMPLATES);
+  for (const [index, name] of managedNames.entries()) {
+    if (profileOrder.includes(name)) {
+      continue;
+    }
+    const anchor = managedNames
+      .slice(0, index)
+      .reverse()
+      .map((sibling) => profileOrder.indexOf(sibling))
+      .find((position) => position >= 0);
+    if (anchor === undefined) {
       profileOrder.push(name);
-      orderSet.add(name);
+    } else {
+      profileOrder.splice(anchor + 1, 0, name);
     }
   }
   llm.profileOrder = profileOrder;

package/src/context/post-turn-tool-result-truncation.ts

@@ -14,8 +14,8 @@ import {
 } from "../security/untrusted-content.js";
 import { safeStringSlice } from "../util/unicode.js";
 
-/** Minimum content length (chars) before a tool result is eligible for truncation. ~2000 tokens at 4 chars/token. */
-export const THRESHOLD_CHARS = 8_000;
+/** Minimum content length (chars) before a tool result is eligible for truncation. ~6250 tokens at 4 chars/token. */
+export const THRESHOLD_CHARS = 25_000;
 
 /** Target size (chars) for the truncated stub. ~300 tokens at 4 chars/token. */
 export const TARGET_CHARS = 1_200;

package/src/conversations/__tests__/message-consolidation.test.ts

@@ -381,3 +381,57 @@ describe("system-card boundaries", () => {
     expect(findDisplayTurnEndIndex(rows, 0)).toBe(0);
   });
 });
+
+describe("provider-error boundaries", () => {
+  const errorMeta = JSON.stringify({
+    messageKind: "provider_error",
+    providerErrorCode: "PROVIDER_BILLING",
+    providerErrorCategory: "credits_exhausted",
+  });
+
+  test("a provider-error row never merges into the preceding assistant run", () => {
+    const { messages } = mergeConsecutiveAssistantMessages([
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "reply" }])),
+      makeMsg(
+        "assistant",
+        JSON.stringify([{ type: "text", text: "You're out of credits." }]),
+        { metadata: errorMeta },
+      ),
+    ]);
+    expect(messages).toHaveLength(2);
+    expect(messages[1]!.metadata).toBe(errorMeta);
+  });
+
+  test("an assistant row never merges into a preceding provider-error row", () => {
+    const { messages } = mergeConsecutiveAssistantMessages([
+      makeMsg(
+        "assistant",
+        JSON.stringify([{ type: "text", text: "You're out of credits." }]),
+        { metadata: errorMeta },
+      ),
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "reply" }])),
+    ]);
+    expect(messages).toHaveLength(2);
+    expect(messages[0]!.metadata).toBe(errorMeta);
+  });
+
+  test("findDisplayTurnEndIndex treats a provider-error row as a single-row turn", () => {
+    const rows = [
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "error" }]), {
+        metadata: errorMeta,
+      }),
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "reply" }])),
+    ];
+    expect(findDisplayTurnEndIndex(rows, 0)).toBe(0);
+  });
+
+  test("findDisplayTurnEndIndex stops an assistant run before a provider-error row", () => {
+    const rows = [
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "reply" }])),
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "error" }]), {
+        metadata: errorMeta,
+      }),
+    ];
+    expect(findDisplayTurnEndIndex(rows, 0)).toBe(0);
+  });
+});

package/src/conversations/message-consolidation.ts

@@ -32,20 +32,21 @@
  */
 
 import type { MessageRow } from "../persistence/conversation-crud.js";
-import { isSystemCardMessage } from "../persistence/conversation-crud.js";
+import { isStandaloneAssistantMessage } from "../persistence/conversation-crud.js";
 import type { ContentBlock } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("message-consolidation");
 
 /**
- * True when a row is a daemon-authored system card (`messageKind:
- * "system_card"` metadata). Cards are standalone display turns: they never
- * fold into an adjacent assistant run and adjacent assistant rows never
- * fold into them.
+ * True when an assistant row is a standalone display turn (system card or
+ * provider-error notice) that never merges with adjacent assistant rows in
+ * either direction. Merging one into an adjacent run would let the anchor's
+ * metadata win and drop the `messageKind` marker from the wire (or stamp it
+ * onto a bubble containing real assistant text).
  */
-export function isSystemCardRow(msg: MessageRow): boolean {
-  return isSystemCardMessage(msg.role, msg.metadata);
+function isStandaloneAssistantRow(msg: MessageRow): boolean {
+  return isStandaloneAssistantMessage(msg.role, msg.metadata);
 }
 
 // ── Block predicates ────────────────────────────────────────────────
@@ -120,8 +121,9 @@ export function findDisplayTurnEndIndex(
   if (messages[startIdx]?.role !== "assistant") {
     return startIdx;
   }
-  // A system card is a single-row display turn — never spans neighbours.
-  if (isSystemCardRow(messages[startIdx]!)) {
+  // System cards and provider-error rows are single-row display turns that
+  // never span neighbours.
+  if (isStandaloneAssistantRow(messages[startIdx]!)) {
     return startIdx;
   }
 
@@ -131,7 +133,7 @@ export function findDisplayTurnEndIndex(
     if (!next) {
       break;
     }
-    if (next.role === "assistant" && !isSystemCardRow(next)) {
+    if (next.role === "assistant" && !isStandaloneAssistantRow(next)) {
       endIdx += 1;
       continue;
     }
@@ -297,15 +299,15 @@ export function mergeConsecutiveAssistantMessages(messages: MessageRow[]): {
 
   for (const msg of messages) {
     const lastIdx = result.length - 1;
-    // System cards stay standalone in both directions: a card never folds
-    // into the preceding assistant run, and the following assistant row
-    // never folds into a card.
+    // System cards and provider-error rows stay standalone in both
+    // directions: neither folds into the preceding assistant run, and the
+    // following assistant row never folds into them.
     const isConsecutiveAssistant =
       msg.role === "assistant" &&
-      !isSystemCardRow(msg) &&
+      !isStandaloneAssistantRow(msg) &&
       lastIdx >= 0 &&
       result[lastIdx].role === "assistant" &&
-      !isSystemCardRow(result[lastIdx]);
+      !isStandaloneAssistantRow(result[lastIdx]);
 
     if (!isConsecutiveAssistant) {
       result.push(msg);

package/src/daemon/__tests__/turn-tail-assistant-reply-notify.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Wiring tests for the `chat.assistant_reply` emit in `runDeferredTurnTail`:
+ * which turn outcomes reach the producer, what the tail hands it, and that the
+ * emit can neither block nor break turn finalization.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+import type { InflightContentWriter } from "../inflight-message-content.js";
+
+// The finalize module's import graph reaches the memory indexer; keep it inert
+// so no embedding backend is touched.
+setConfig("memory", { enabled: false, v2: { enabled: false } });
+
+const CONVERSATION_ID = "conv-tail-1";
+const ASSISTANT_MESSAGE_ID = "msg-assistant-1";
+const USER_MESSAGE_ID = "msg-user-1";
+
+interface EmitCall {
+  conversationId: string;
+  assistantMessageId: string;
+  userMessageId: string | undefined;
+  replyDeliveredInAppOnly?: boolean;
+}
+
+const emitCalls: EmitCall[] = [];
+/** Ordered trace of the tail's deferred work, for the ordering assertion. */
+const trace: string[] = [];
+let producerBehavior: "resolve" | "reject" | "hang" = "resolve";
+
+mock.module("../../notifications/assistant-reply-producer.js", () => ({
+  emitAssistantReplyNotification: (params: EmitCall): Promise<void> => {
+    emitCalls.push({
+      conversationId: params.conversationId,
+      assistantMessageId: params.assistantMessageId,
+      userMessageId: params.userMessageId,
+      ...("replyDeliveredInAppOnly" in params
+        ? { replyDeliveredInAppOnly: params.replyDeliveredInAppOnly }
+        : {}),
+    });
+    trace.push("emit");
+    if (producerBehavior === "reject") {
+      const rejected = Promise.reject(new Error("simulated producer failure"));
+      // The call site fires the producer without awaiting it, so nothing in
+      // the tail observes this rejection. Settle it here so the failure stays
+      // a test fixture rather than a process-level unhandled rejection.
+      rejected.catch(() => {});
+      return rejected;
+    }
+    if (producerBehavior === "hang") {
+      return new Promise<void>(() => {});
+    }
+    return Promise.resolve();
+  },
+}));
+
+const realCrud = await import("../../persistence/conversation-crud.js");
+mock.module("../../persistence/conversation-crud.js", () => ({
+  ...realCrud,
+  // No conversation row: the tail's truncation and disk-sync steps
+  // short-circuit, keeping these tests on the notify wiring.
+  getConversation: () => null,
+}));
+
+const { runDeferredTurnTail } =
+  await import("../conversation-turn-finalize.js");
+
+const rlog = makeMockLogger() as Parameters<
+  typeof runDeferredTurnTail
+>[0]["rlog"];
+
+async function runTail(overrides: {
+  turnCompleted: boolean;
+  lastAssistantMessageId?: string | undefined;
+  deferredFinalizeEffects?: ReadonlyArray<() => Promise<void>>;
+  userMessageId?: string | undefined;
+  replyDeliveredInAppOnly?: boolean;
+}): Promise<void> {
+  await runDeferredTurnTail({
+    ctx: { conversationId: CONVERSATION_ID, messages: [] },
+    state: {
+      deferredFinalizeEffects: overrides.deferredFinalizeEffects ?? [],
+      lastAssistantMessageId:
+        "lastAssistantMessageId" in overrides
+          ? overrides.lastAssistantMessageId
+          : ASSISTANT_MESSAGE_ID,
+      inflightWriters: new Map<string, InflightContentWriter>(),
+    },
+    rlog,
+    generationCompletedAt: Date.now(),
+    turnCompleted: overrides.turnCompleted,
+    userMessageId:
+      "userMessageId" in overrides ? overrides.userMessageId : USER_MESSAGE_ID,
+    ...(overrides.replyDeliveredInAppOnly
+      ? { replyDeliveredInAppOnly: true }
+      : {}),
+  });
+}
+
+beforeEach(() => {
+  emitCalls.length = 0;
+  trace.length = 0;
+  producerBehavior = "resolve";
+});
+
+describe("runDeferredTurnTail assistant-reply notification", () => {
+  test("emits once for a completed turn", async () => {
+    await runTail({ turnCompleted: true });
+
+    expect(emitCalls).toEqual([
+      {
+        conversationId: CONVERSATION_ID,
+        assistantMessageId: ASSISTANT_MESSAGE_ID,
+        userMessageId: USER_MESSAGE_ID,
+      },
+    ]);
+  });
+
+  test("forwards the app-only delivery marker to the producer", async () => {
+    await runTail({ turnCompleted: true, replyDeliveredInAppOnly: true });
+
+    expect(emitCalls).toEqual([
+      {
+        conversationId: CONVERSATION_ID,
+        assistantMessageId: ASSISTANT_MESSAGE_ID,
+        userMessageId: USER_MESSAGE_ID,
+        replyDeliveredInAppOnly: true,
+      },
+    ]);
+  });
+
+  test("omits the app-only delivery marker for an ordinary turn", async () => {
+    await runTail({ turnCompleted: true });
+
+    expect(emitCalls[0]).not.toHaveProperty("replyDeliveredInAppOnly");
+  });
+
+  test("stays silent for a handed-off or cancelled turn", async () => {
+    await runTail({ turnCompleted: false });
+
+    expect(emitCalls).toEqual([]);
+  });
+
+  test("stays silent when the turn produced no assistant row", async () => {
+    await runTail({ turnCompleted: true, lastAssistantMessageId: undefined });
+
+    expect(emitCalls).toEqual([]);
+  });
+
+  test("emits after the deferred finalize effects have run", async () => {
+    await runTail({
+      turnCompleted: true,
+      deferredFinalizeEffects: [
+        async () => {
+          trace.push("effect-1");
+        },
+        async () => {
+          trace.push("effect-2");
+        },
+      ],
+    });
+
+    expect(trace).toEqual(["effect-1", "effect-2", "emit"]);
+  });
+
+  test("completes without awaiting the producer, even when it never settles", async () => {
+    producerBehavior = "hang";
+
+    await runTail({ turnCompleted: true });
+
+    expect(emitCalls).toHaveLength(1);
+  });
+
+  test("survives a failing producer", async () => {
+    producerBehavior = "reject";
+
+    await runTail({ turnCompleted: true });
+
+    expect(emitCalls).toHaveLength(1);
+  });
+});

package/src/daemon/__tests__/turn-tail-deleted-conversation.test.ts

@@ -0,0 +1,181 @@
+/**
+ * `runDeferredTurnTail` runs after the terminal SSE, so the user can delete the
+ * conversation while its awaited bookkeeping is still draining. These tests pin
+ * that the tail's two filesystem steps (tool-result spooling and the JSONL disk
+ * mirror) read the conversation fresh and skip once it is gone, rather than
+ * rebuilding a deleted conversation's directory from in-memory history.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+import type { ConversationRow } from "../../persistence/conversation-crud.js";
+import type { Message } from "../../providers/types.js";
+import type { InflightContentWriter } from "../inflight-message-content.js";
+
+// The finalize module's import graph reaches the memory indexer; keep it inert
+// so no embedding backend is touched.
+setConfig("memory", { enabled: false, v2: { enabled: false } });
+
+const CONVERSATION_ID = "conv-tail-delete-1";
+const ASSISTANT_MESSAGE_ID = "msg-assistant-1";
+const USER_MESSAGE_ID = "msg-user-1";
+const CONVERSATION_DIR = "/tmp/vellum-test/conv-tail-delete-1";
+
+/** Flipped by a deferred finalize effect to model a mid-tail deletion. */
+let conversationDeleted = false;
+let getConversationCalls = 0;
+const resolvedDirCalls: string[] = [];
+const truncateCalls: string[] = [];
+const diskSyncCalls: string[] = [];
+
+const TRUNCATED_MESSAGES: Message[] = [{ role: "user", content: [] }];
+
+mock.module("../../notifications/assistant-reply-producer.js", () => ({
+  emitAssistantReplyNotification: (): Promise<void> => Promise.resolve(),
+}));
+
+function makeConversation(): ConversationRow {
+  return {
+    id: CONVERSATION_ID,
+    title: null,
+    createdAt: 1700000000000,
+    updatedAt: 1700000000000,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    contextCompactedAt: null,
+    historyStrippedAt: null,
+    slackContextCompactionWatermarkTs: null,
+    slackContextCompactionWatermarkAt: null,
+    conversationType: "chat",
+    source: "user",
+    originChannel: null,
+    originInterface: null,
+    forkParentConversationId: null,
+    forkParentMessageId: null,
+    isAutoTitle: 0,
+    scheduleJobId: null,
+    lastMessageAt: null,
+    archivedAt: null,
+    surfacedAt: null,
+    inferenceProfile: null,
+    enabledPlugins: null,
+    inferenceProfileSessionId: null,
+    inferenceProfileExpiresAt: null,
+    lastNotifiedInferenceProfile: null,
+    processingStartedAt: null,
+  };
+}
+
+const realCrud = await import("../../persistence/conversation-crud.js");
+mock.module("../../persistence/conversation-crud.js", () => ({
+  ...realCrud,
+  getConversation: (): ConversationRow | null => {
+    getConversationCalls += 1;
+    return conversationDeleted ? null : makeConversation();
+  },
+}));
+
+const realDirectories =
+  await import("../../persistence/conversation-directories.js");
+mock.module("../../persistence/conversation-directories.js", () => ({
+  ...realDirectories,
+  getResolvedConversationDirPath: (id: string): string => {
+    resolvedDirCalls.push(id);
+    return CONVERSATION_DIR;
+  },
+}));
+
+const realTruncation =
+  await import("../../context/post-turn-tool-result-truncation.js");
+mock.module("../../context/post-turn-tool-result-truncation.js", () => ({
+  ...realTruncation,
+  derefToolResultReReads: (messages: Message[]) => ({
+    messages,
+    dereferencedCount: 0,
+  }),
+  postTurnTruncateToolResults: (
+    _messages: Message[],
+    options: { conversationDir: string },
+  ) => {
+    truncateCalls.push(options.conversationDir);
+    return { messages: TRUNCATED_MESSAGES, truncatedCount: 0 };
+  },
+}));
+
+const realDiskView =
+  await import("../../persistence/conversation-disk-view.js");
+mock.module("../../persistence/conversation-disk-view.js", () => ({
+  ...realDiskView,
+  syncMessageToDisk: (_conversationId: string, messageId: string): void => {
+    diskSyncCalls.push(messageId);
+  },
+}));
+
+const { runDeferredTurnTail } =
+  await import("../conversation-turn-finalize.js");
+
+const rlog = makeMockLogger() as Parameters<
+  typeof runDeferredTurnTail
+>[0]["rlog"];
+
+/** Runs the tail with one deferred effect standing in for the turn's bookkeeping. */
+async function runTail(
+  deferredEffect: () => Promise<void>,
+): Promise<Message[]> {
+  const ctx = { conversationId: CONVERSATION_ID, messages: [] as Message[] };
+  await runDeferredTurnTail({
+    ctx,
+    state: {
+      deferredFinalizeEffects: [deferredEffect],
+      lastAssistantMessageId: ASSISTANT_MESSAGE_ID,
+      inflightWriters: new Map<string, InflightContentWriter>(),
+    },
+    rlog,
+    generationCompletedAt: Date.now(),
+    turnCompleted: true,
+    userMessageId: USER_MESSAGE_ID,
+  });
+  return ctx.messages;
+}
+
+beforeEach(() => {
+  conversationDeleted = false;
+  getConversationCalls = 0;
+  resolvedDirCalls.length = 0;
+  truncateCalls.length = 0;
+  diskSyncCalls.length = 0;
+});
+
+describe("runDeferredTurnTail conversation deleted mid-tail", () => {
+  test("skips the filesystem steps when the conversation is gone", async () => {
+    const messages = await runTail(async () => {
+      conversationDeleted = true;
+    });
+
+    expect(resolvedDirCalls).toEqual([]);
+    expect(truncateCalls).toEqual([]);
+    expect(diskSyncCalls).toEqual([]);
+    expect(messages).toEqual([]);
+  });
+
+  test("reads the conversation once more before the filesystem steps", async () => {
+    await runTail(async () => {
+      conversationDeleted = true;
+    });
+
+    expect(getConversationCalls).toBe(2);
+  });
+
+  test("runs the filesystem steps when the conversation survives", async () => {
+    const messages = await runTail(async () => {});
+
+    expect(resolvedDirCalls).toEqual([CONVERSATION_ID]);
+    expect(truncateCalls).toEqual([CONVERSATION_DIR]);
+    expect(diskSyncCalls).toEqual([ASSISTANT_MESSAGE_ID]);
+    expect(messages).toEqual(TRUNCATED_MESSAGES);
+  });
+});