@vellumai/assistant 0.11.1-staging.1 → 0.11.1-staging.3

package/openapi.yaml

@@ -20459,7 +20459,9 @@ paths:
     delete:
       operationId: messages_queued_by_id_delete
       summary: Delete a queued message
-      description: Remove a pending message from the conversation queue before it is processed.
+      description:
+        Remove a pending message from the conversation queue before it is processed. Broadcasts
+        `message_queued_deleted` so every client can close out the pending row.
       tags:
         - messages
       parameters:
@@ -20477,6 +20479,10 @@ paths:
       responses:
         "200":
           description: Successful response
+        "403":
+          description: The queued message was enqueued by a different actor principal.
+        "404":
+          description: Conversation or queued message not found.
   /v1/messages/queued/{id}/steer:
     post:
       operationId: messages_queued_by_id_steer_post

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-staging.1",
+  "version": "0.11.1-staging.3",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-override-profile.test.ts

@@ -276,21 +276,28 @@ import { VELLUM_MANAGED_CONNECTION_NAME } from "../providers/vellum-model-routin
 // Connection-aware resolver path: satisfy
 // `tryResolveProviderForConnectionName` lookups so resolveDefaultProvider
 // returns a usable provider for any connection name the winning profile
-// references. The managed connection must carry the provider the catalog
-// `balanced` default declares (fireworks) or resolution rejects the row as a
-// provider mismatch; other names behave as personal anthropic connections.
+// references. The managed connection must be the platform-auth sentinel row:
+// a managed profile routing through anything else resolves to the platform
+// instead. Other names behave as personal anthropic connections.
 mock.module("../providers/inference/connections.js", () => ({
-  getConnection: (_db: unknown, name: string) => ({
-    id: 1,
-    name,
-    provider:
-      name === VELLUM_MANAGED_CONNECTION_NAME ? "fireworks" : "anthropic",
-    auth_strategy: "user_managed_credential",
-    credential_alias: null,
-    metadata_json: null,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
-  }),
+  getConnection: (_db: unknown, name: string) =>
+    name === VELLUM_MANAGED_CONNECTION_NAME
+      ? {
+          id: 1,
+          name,
+          provider: "vellum",
+          auth: { type: "platform" },
+        }
+      : {
+          id: 1,
+          name,
+          provider: "anthropic",
+          auth_strategy: "user_managed_credential",
+          credential_alias: null,
+          metadata_json: null,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+        },
 }));
 
 /**

package/src/__tests__/config-callsite-patch-merge.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Pins the `deepMergeOverwrite` behaviour that the Action Overrides editor
+ * depends on when it builds an `llm.callSites` patch (LUM-2949).
+ *
+ * A persisted call-site entry may carry tuning the web editor renders no
+ * control for (`effort`, `thinking`, `maxTokens`, ...). The editor decides
+ * per entry whether to send the picker triple, send `null`, or omit the key
+ * entirely, and each of those choices is only correct because of how this
+ * merge treats it. Asserting on the patch body alone would not catch a
+ * change here, so the contract is pinned where it lives.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { deepMergeOverwrite } from "../config/loader.js";
+
+type Raw = Record<string, unknown>;
+
+function callSites(entries: Raw): Raw {
+  return { llm: { callSites: entries } };
+}
+
+function mergedCallSites(before: Raw, patch: Raw): Raw {
+  const raw = callSites(before);
+  deepMergeOverwrite(raw, callSites(patch));
+  return (raw.llm as Raw).callSites as Raw;
+}
+
+const TUNED = {
+  profile: "latency-optimized",
+  effort: "low",
+  thinking: { enabled: false },
+};
+
+describe("llm.callSites patch merge", () => {
+  test("an omitted key keeps its persisted value", () => {
+    // What the editor sends for an active row: the picker triple only.
+    const after = mergedCallSites(
+      { voiceFrontDoor: TUNED },
+      { voiceFrontDoor: { profile: "balanced", provider: null, model: null } },
+    );
+    expect(after.voiceFrontDoor).toEqual({
+      profile: "balanced",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("a null on an absent key is a no-op, not a write", () => {
+    const after = mergedCallSites(
+      { voiceFrontDoor: TUNED },
+      { heartbeatAgent: null },
+    );
+    expect(after).toEqual({ voiceFrontDoor: TUNED });
+  });
+
+  test("a null deletes the whole entry, tuning included", () => {
+    // Why the editor must not send `null` for a row the user left alone:
+    // an entry holding only tuning would be erased.
+    const after = mergedCallSites(
+      { tuningOnly: { effort: "low", thinking: { enabled: false } } },
+      { tuningOnly: null },
+    );
+    expect("tuningOnly" in after).toBe(false);
+  });
+
+  test("omitting a tuning-only entry leaves it untouched", () => {
+    const before = {
+      tuningOnly: { effort: "low", thinking: { enabled: false } },
+    };
+    const after = mergedCallSites(before, {
+      heartbeatAgent: { profile: "balanced", provider: null, model: null },
+    });
+    expect(after.tuningOnly).toEqual({
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("an explicit null clears a scalar that is present", () => {
+    // The picker triple relies on this to drop a stale provider/model pin.
+    const after = mergedCallSites(
+      { pinned: { provider: "anthropic", model: "claude-fable-5" } },
+      { pinned: { profile: "balanced", provider: null, model: null } },
+    );
+    expect(after.pinned).toEqual({
+      profile: "balanced",
+      provider: null,
+      model: null,
+    });
+  });
+});

package/src/__tests__/config-loader-backfill.test.ts

@@ -650,7 +650,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles).toEqual({});
     // Default content resolves from the code catalog via the effective view.
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
     expect(effectiveBalanced?.provider).toBe("vellum");
     expect(effectiveBalanced?.provider_connection).toBeUndefined();
   });
@@ -978,7 +978,7 @@ describe("loadConfig startup behavior", () => {
     // Resolution ignores the drifted body: a managed-source entry contributes
     // only label/status/topP, everything else comes from the catalog.
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
     expect(effectiveBalanced?.provider_connection).toBeUndefined();
   });
 
@@ -1058,7 +1058,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced).toEqual(drifted);
     expect(raw.llm.activeProfile).toBe("balanced");
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
     expect(effectiveBalanced?.maxTokens).toBe(32000);
     expect(effectiveBalanced?.provider_connection).toBeUndefined();
     // The catalog body carries no topP and the entry has none, so the
@@ -1090,7 +1090,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced).toEqual(edited);
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
     // Content is served from the catalog...
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
     // ...with the user's label and status overlaid.
     expect(effectiveBalanced?.label).toBe("My Default");
     expect(effectiveBalanced?.status).toBe("disabled");
@@ -1115,7 +1115,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced).toEqual(stub);
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
     expect(effectiveBalanced?.label).toBe("My Default");
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
   });
 
   test("off-platform boot preserves user-toggled status on a managed stub", () => {
@@ -1137,7 +1137,7 @@ describe("loadConfig startup behavior", () => {
     expect(effectiveBalanced?.status).toBe("disabled");
     // Content still comes from the catalog — only label/status/topP are
     // workspace-owned.
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
   });
 
   test("boot preserves a user-edited topP override on a managed stub", () => {
@@ -1161,7 +1161,7 @@ describe("loadConfig startup behavior", () => {
     expect(effectiveBalanced?.topP).toBe(0.5);
     // Content still comes from the catalog — topP is workspace-owned, the
     // rest is code-owned.
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
   });
 
   test("effective balanced profile carries no topP override by default", () => {
@@ -1216,7 +1216,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced).toBeUndefined();
     const effectiveBalanced = getEffectiveProfile(raw.llm.profiles, "balanced");
     expect(effectiveBalanced?.label).toBe("Balanced");
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
     // Status is unset — the default resolves active.
     expect("status" in (effectiveBalanced ?? {})).toBe(false);
   });
@@ -1295,7 +1295,7 @@ describe("loadConfig startup behavior", () => {
     // overlay boot. The overlay-set label is what shows through the
     // effective view.
     expect(mainAgentConfig.provider).toBe("vellum");
-    expect(mainAgentConfig.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(mainAgentConfig.model).toBe("gpt-5.6-luna");
 
     const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
     expect(raw.llm.profiles.balanced).toEqual({
@@ -1326,7 +1326,7 @@ describe("loadConfig startup behavior", () => {
     );
     expect(effectiveBalanced?.provider).toBe("vellum");
     expect(effectiveBalanced?.provider_connection).toBeUndefined();
-    expect(effectiveBalanced?.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(effectiveBalanced?.model).toBe("gpt-5.6-luna");
     expect(effectiveBalanced?.maxTokens).toBe(32000);
     expect(effectiveBalanced?.thinking).toEqual({
       enabled: true,

package/src/__tests__/drain-requeue-on-contention.test.ts

@@ -19,12 +19,17 @@ import {
 interface FakeEvent {
   type: string;
   message?: string;
+  conversationId?: string;
+  requestId?: string;
+  position?: number;
+  clientMessageId?: string;
 }
 
 function makeQueued(
   content: string,
   requestId: string,
   events: FakeEvent[],
+  extra?: Partial<QueuedMessage>,
 ): QueuedMessage {
   return {
     content,
@@ -34,6 +39,7 @@ function makeQueued(
       events.push(event);
     },
     sentAt: Date.now(),
+    ...extra,
   } as unknown as QueuedMessage;
 }
 
@@ -200,3 +206,121 @@ describe("drainQueue under processing-lock contention", () => {
     ).toBe(1);
   });
 });
+
+/**
+ * The corrective `message_requeued` event.
+ *
+ * A drain announces `message_dequeued` before the steps that can send the
+ * message back, so a client that cleared its pending indicator on that
+ * announcement needs to be told the message is queued again. The rule is
+ * announcement-scoped: a requeue that happens before the announcement owes
+ * clients nothing, because they never stopped showing the row as queued.
+ */
+describe("message_requeued corrective event", () => {
+  test("a busy persist tells the sender its announced message is queued again", async () => {
+    const events: FakeEvent[] = [];
+    const { conversation, queue } = makeFakeConversation({
+      persistError: new Error(CONVERSATION_BUSY_MESSAGE),
+    });
+    queue.push(
+      makeQueued("hello there", "r1", events, {
+        clientMessageId: "nonce-1",
+      }),
+    );
+    queue.push(makeQueued("and another", "r2", events));
+
+    await drainQueue(conversation as never);
+
+    expect(events.map((event) => event.type)).toEqual([
+      "message_dequeued",
+      "message_requeued",
+    ]);
+    expect(events[1]).toEqual({
+      type: "message_requeued",
+      conversationId: "conv-drain-requeue",
+      requestId: "r1",
+      // Back at the head, so 1 of the 2 visible queued items.
+      position: 1,
+      clientMessageId: "nonce-1",
+    });
+  });
+
+  test("a requeue before the dequeue announcement stays silent", async () => {
+    const events: FakeEvent[] = [];
+    const { conversation, queue } = makeFakeConversation({ processing: true });
+    queue.push(makeQueued("hello there", "r1", events));
+
+    await drainQueue(conversation as never);
+
+    // The early lock check requeues before announcing anything, so a
+    // corrective event here would contradict what the client is showing.
+    expect(events).toEqual([]);
+    expect(queue.length).toBe(1);
+  });
+
+  test("only the batch member whose dequeue was announced is corrected", async () => {
+    const headEvents: FakeEvent[] = [];
+    const tailEvents: FakeEvent[] = [];
+    const { conversation, queue } = makeFakeConversation({
+      persistError: new Error(CONVERSATION_BUSY_MESSAGE),
+    });
+    queue.push(makeQueued("hello there", "r1", headEvents));
+    queue.push(makeQueued("and another", "r2", tailEvents));
+
+    await drainQueue(conversation as never);
+
+    // The batch drain announces per member as it walks the batch, and the
+    // head's busy persist ends the walk before the tail is announced.
+    expect(headEvents.map((event) => event.type)).toEqual([
+      "message_dequeued",
+      "message_requeued",
+    ]);
+    expect(tailEvents).toEqual([]);
+    expect(queue.peek(0)?.requestId).toBe("r1");
+    expect(queue.peek(1)?.requestId).toBe("r2");
+  });
+
+  test("a hidden send is announced but never corrected", async () => {
+    const events: FakeEvent[] = [];
+    const { conversation, queue } = makeFakeConversation({
+      persistError: new Error(CONVERSATION_BUSY_MESSAGE),
+    });
+    queue.push(
+      makeQueued("wizard closed", "r1", events, {
+        metadata: { hidden: true },
+      }),
+    );
+
+    await drainQueue(conversation as never);
+
+    // Hidden sends get no queued ack and render no client row, so there is
+    // nothing for a corrective event to restore.
+    expect(events.some((event) => event.type === "message_requeued")).toBe(
+      false,
+    );
+    expect(queue.peek(0)?.requestId).toBe("r1");
+  });
+
+  test("a second contention round corrects the message again", async () => {
+    const events: FakeEvent[] = [];
+    const { conversation, queue } = makeFakeConversation({
+      persistErrors: [
+        new Error(CONVERSATION_BUSY_MESSAGE),
+        new Error(CONVERSATION_BUSY_MESSAGE),
+      ],
+    });
+    queue.push(makeQueued("hello there", "r1", events));
+
+    await drainQueue(conversation as never);
+    await drainQueue(conversation as never);
+
+    // Each round re-announces the dequeue, so each round owes its own
+    // correction: the flag settles per announcement, not once per message.
+    expect(events.map((event) => event.type)).toEqual([
+      "message_dequeued",
+      "message_requeued",
+      "message_dequeued",
+      "message_requeued",
+    ]);
+  });
+});

package/src/__tests__/managed-profile-guard.test.ts

@@ -1067,7 +1067,7 @@ describe("code-owned default profiles — wire view and write normalization", ()
     });
     const response = (await getRoute.handler({})) as Record<string, any>;
     const wireBalanced = response.llm.profiles.balanced;
-    expect(wireBalanced.model).toBe("accounts/fireworks/models/glm-5p2");
+    expect(wireBalanced.model).toBe("gpt-5.6-luna");
     expect(wireBalanced.provider).toBe("vellum");
     expect(wireBalanced.provider_connection).toBeUndefined();
     expect(wireBalanced.status).toBe("disabled");
@@ -1314,9 +1314,7 @@ describe("code-owned default profiles — echoes over stale on-disk bodies", ()
     });
     const response = (await getRoute.handler({})) as Record<string, any>;
     // The wire view serves catalog content, not the stale body.
-    expect(response.llm.profiles.balanced.model).toBe(
-      "accounts/fireworks/models/glm-5p2",
-    );
+    expect(response.llm.profiles.balanced.model).toBe("gpt-5.6-luna");
     const result = await patchRoute.handler({
       body: { llm: { profiles: response.llm.profiles } },
     });