@vellumai/assistant 0.12.5-dev.202609281620.da5cb5b → 0.12.5-dev.202609281822.fb70dee

package/openapi.yaml

@@ -8042,8 +8042,9 @@ paths:
             Filter by conversation type. Pass "background" to list background and scheduled conversations together (the
             back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the
             standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with
-            archiveStatus=all for a whole-history read; rows are recency-ordered (COALESCE(last_message_at, updated_at)
-            descending) like every other list read, and pinned rows are never appended to it.
+            archiveStatus=all for a whole-history read; rows are ordered by last activity (the later of the last message
+            and the time the row was marked done, descending) like every other list read, and pinned rows are never
+            appended to it.
         - name: archiveStatus
           in: query
           required: false
@@ -8083,8 +8084,9 @@ paths:
           description:
             Filter to a single group, so each sidebar section can load independently of the paginated list. Pass
             "system:all" for conversations in no group, "system:pinned" for the Pinned section, or a custom group id. A
-            group-scoped request is recency-ordered like every list read (COALESCE(last_message_at, updated_at)
-            descending) and never has pinned rows appended to it. Omit to span every group.
+            group-scoped request is ordered by last activity like every list read (the later of the last message and the
+            time the row was marked done, descending) and never has pinned rows appended to it. Omit to span every
+            group.
         - name: needsAttention
           in: query
           required: false
@@ -8340,10 +8342,14 @@ paths:
                         - sortPosition
                         - isSystemGroup
                       additionalProperties: false
+                  orderedBy:
+                    type: string
+                    const: lastActivity
                 required:
                   - conversations
                   - nextOffset
                   - hasMore
+                  - orderedBy
                 additionalProperties: false
     post:
       operationId: conversations_post

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.5-dev.202609281620.da5cb5b",
+  "version": "0.12.5-dev.202609281822.fb70dee",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/byok-default-profile-ensure.test.ts

@@ -302,6 +302,13 @@ describe("ensureByokDefaultProfiles", () => {
       "cost-optimized",
       "accounts/fireworks/models/deepseek-v4-flash",
     ],
+    [
+      "fireworks",
+      "cost-optimized",
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
+    ],
+    ["fireworks", "balanced", "accounts/fireworks/models/deepseek-v4p1-flash"],
+    ["fireworks", "quality-optimized", "accounts/fireworks/models/kimi-k2p6"],
   ] as const)(
     "a historical intent-era copy converts (%s %s pinned to %s)",
     (provider, key, model) => {

package/src/__tests__/config-get-vision-flag.test.ts

@@ -40,7 +40,7 @@ describe("GET /v1/config profile vision enrichment", () => {
     seedProfiles({
       "test-no-vision": {
         provider: "fireworks",
-        model: "accounts/fireworks/models/glm-5p2",
+        model: "accounts/fireworks/models/glm-5p3",
       },
     });
 

package/src/__tests__/config-loader-validation-reset-notice.test.ts

@@ -171,7 +171,7 @@ describe("config-validation-reset notice sentinel", () => {
             profiles: {
               "glm-default": {
                 provider: "vellum",
-                model: "accounts/fireworks/models/glm-5p2",
+                model: "accounts/fireworks/models/glm-5p3",
               },
             },
             activeProfile: "glm-default",
@@ -193,7 +193,7 @@ describe("config-validation-reset notice sentinel", () => {
     expect(config.llm.activeProfile).toBe("glm-default");
     expect(config.llm.callSites.mainAgent?.profile).toBe("glm-default");
     expect(config.llm.profiles["glm-default"]?.model).toBe(
-      "accounts/fireworks/models/glm-5p2",
+      "accounts/fireworks/models/glm-5p3",
     );
   });
 

package/src/__tests__/conversation-pairing.test.ts

@@ -116,6 +116,7 @@ mock.module("../config/assistant-initiated-threads-gate.js", () => ({
   isAssistantInitiatedThreadsEnabled: () => assistantInitiatedThreadsEnabled,
 }));
 
+import { resolveAssistantInitiatedThread } from "../notifications/assistant-initiated-thread.js";
 import { pairDeliveryWithConversation } from "../notifications/conversation-pairing.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type {
@@ -1478,6 +1479,117 @@ describe("pairDeliveryWithConversation", () => {
         ...overrides,
       });
 
+    test("a prepared resolution is reused even if the source changes before pairing", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      const signal = share({
+        conversationMetadata: { groupId: "group-123" },
+      });
+      const original = structuredClone(signal);
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+      getConversationMock.mockClear();
+      mockExistingConversations[signal.sourceContextId] = {
+        id: signal.sourceContextId,
+        source: "user",
+        title: null,
+        conversationType: "standard",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "vellum",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.createdNewConversation).toBe(true);
+      expect(result.messageId).toBe("msg-001");
+      expect(createConversationMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          source: "assistant_initiated",
+          groupId: "group-123",
+        }),
+      );
+      expect(getConversationMock).not.toHaveBeenCalled();
+      expect(signal).toEqual(original);
+    });
+
+    test("an ineligible prepared resolution retains passive pairing when the flag changes", async () => {
+      const signal = share();
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+      assistantInitiatedThreadsEnabled = true;
+      mockExistingConversations[signal.sourceContextId] = {
+        id: signal.sourceContextId,
+        source: "heartbeat",
+        title: null,
+        conversationType: "background",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "vellum",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.createdNewConversation).toBe(false);
+      expect(result.conversationId).toBe(signal.sourceContextId);
+      expect(createConversationMock).not.toHaveBeenCalled();
+      expect(addMessageMock).toHaveBeenCalledTimes(1);
+    });
+
+    test.each(["slack", "telegram", "discord"] as const)(
+      "%s retains the producer metadata despite a prepared vellum resolution",
+      async (channel) => {
+        assistantInitiatedThreadsEnabled = true;
+        const signal = share({
+          conversationMetadata: { groupId: "group-123" },
+        });
+        const original = structuredClone(signal);
+        const assistantInitiatedThread =
+          resolveAssistantInitiatedThread(signal);
+        getConversationMock.mockClear();
+
+        const result = await pairDeliveryWithConversation(
+          signal,
+          channel,
+          makeCopy(),
+          { assistantInitiatedThread },
+        );
+
+        expect(result.createdNewConversation).toBe(true);
+        expect(result.strategy).toBe("continue_existing_conversation");
+        expect(createConversationMock).toHaveBeenCalledWith(
+          expect.objectContaining({
+            conversationType: "background",
+            source: "notification",
+            groupId: "group-123",
+          }),
+        );
+        expect(addMessageMock).not.toHaveBeenCalled();
+        expect(getConversationMock).not.toHaveBeenCalled();
+        expect(signal).toEqual(original);
+      },
+    );
+
+    test("platform delivery does not pair a prepared vellum resolution", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      const signal = share();
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "platform",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.strategy).toBe("push_only");
+      expect(result.createdNewConversation).toBe(false);
+      expect(result.conversationId).toBeNull();
+      expect(createConversationMock).not.toHaveBeenCalled();
+      expect(addMessageMock).not.toHaveBeenCalled();
+    });
+
     test("flag on: a share from a background run materializes a section thread", async () => {
       assistantInitiatedThreadsEnabled = true;
       mockExistingConversations["conv-heartbeat"] = {

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -1,8 +1,26 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { saveRawConfig } from "../config/loader.js";
+import type { NotificationSignal } from "../notifications/signal.js";
 import type { NotificationChannel } from "../notifications/types.js";
 
+let assistantInitiatedCandidate = false;
+const resolveAssistantInitiatedThreadMock = mock(
+  (signal: NotificationSignal) => ({
+    isCandidate: assistantInitiatedCandidate,
+    vellumSignal: assistantInitiatedCandidate
+      ? {
+          ...signal,
+          requiresConversation: true,
+          conversationMetadata: { source: "assistant_initiated" },
+        }
+      : signal,
+  }),
+);
+mock.module("../notifications/assistant-initiated-thread.js", () => ({
+  resolveAssistantInitiatedThread: resolveAssistantInitiatedThreadMock,
+}));
+
 const evaluateSignalMock = mock();
 const enforceRoutingIntentMock = mock();
 const updateDecisionMock = mock();
@@ -113,6 +131,8 @@ import {
 
 beforeEach(() => {
   saveRawConfig({});
+  assistantInitiatedCandidate = false;
+  resolveAssistantInitiatedThreadMock.mockClear();
   writeHomeFeedItemForSignalMock.mockClear();
   evaluateSignalMock.mockReset();
   enforceRoutingIntentMock.mockReset();
@@ -1020,3 +1040,142 @@ describe("classifyNotificationReceipt", () => {
     ).toBe("unknown");
   });
 });
+
+describe("emitNotificationSignal From me push defaults", () => {
+  const params = {
+    sourceEventName: "assistant.share",
+    sourceChannel: "assistant_tool" as const,
+    sourceContextId: "conv-background",
+    attentionHints: {
+      urgency: "low" as const,
+      requiresAction: false,
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+  };
+  const decision = (selectedChannels: NotificationChannel[] = ["vellum"]) => ({
+    shouldNotify: true,
+    selectedChannels,
+    reasoningSummary: "Assistant-authored share",
+    renderedCopy: { vellum: { title: "An update", body: "A useful result." } },
+    dedupeKey: "share-1",
+    confidence: 1,
+    fallbackUsed: false,
+    persistedDecisionId: "decision-share",
+  });
+
+  beforeEach(() => {
+    assistantInitiatedCandidate = true;
+    evaluateSignalMock.mockResolvedValue(decision());
+  });
+
+  test("adds configured platform after routing and persists the final decision", async () => {
+    const result = await emitNotificationSignal(params);
+    expect(result.selectedChannels).toEqual(["vellum", "platform"]);
+    expect(resolveAssistantInitiatedThreadMock).toHaveBeenCalledTimes(1);
+    expect(updateDecisionMock).toHaveBeenCalledWith(
+      "decision-share",
+      expect.objectContaining({
+        selectedChannels: ["vellum", "platform"],
+      }),
+    );
+    expect(dispatchDecisionMock.mock.calls[0]?.[0]).toMatchObject({
+      attentionHints: { urgency: "low" },
+    });
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: {
+        platformAdded: true,
+        resolution: {
+          isCandidate: true,
+          vellumSignal: {
+            requiresConversation: true,
+            conversationMetadata: { source: "assistant_initiated" },
+          },
+        },
+      },
+    });
+  });
+
+  test.each([
+    "quiet",
+    "unconfigured",
+    "noncandidate",
+    "suppressed",
+    "single_channel",
+    "external_only",
+    "vellum_allowlist",
+  ])("respects %s policy without adding platform", async (scenario) => {
+    assistantInitiatedCandidate = scenario !== "noncandidate";
+    isPlatformClientConfiguredMock.mockResolvedValue(
+      scenario !== "unconfigured",
+    );
+    evaluateSignalMock.mockResolvedValue({
+      ...decision(scenario === "external_only" ? ["telegram"] : ["vellum"]),
+      shouldNotify: scenario !== "suppressed",
+    });
+    const result = await emitNotificationSignal({
+      ...params,
+      routingIntent:
+        scenario === "single_channel" ? "single_channel" : undefined,
+      contextPayload: {
+        quiet: scenario === "quiet",
+        ...(scenario === "vellum_allowlist"
+          ? { channelAllowlist: ["vellum"] }
+          : {}),
+      },
+    });
+    expect(result.selectedChannels).not.toContain("platform");
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: { platformAdded: false },
+    });
+  });
+
+  test("keeps existing platform and external selections independent of this feature", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      decision(["vellum", "platform", "telegram"]),
+    );
+    const result = await emitNotificationSignal({
+      ...params,
+      contextPayload: { quiet: true },
+    });
+    expect(result.selectedChannels).toEqual(["vellum", "platform", "telegram"]);
+    expect(isPlatformClientConfiguredMock).not.toHaveBeenCalled();
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: { platformAdded: false },
+    });
+  });
+
+  test("probes an unbound platform once across urgency and From me policy", async () => {
+    isPlatformClientConfiguredMock.mockResolvedValue(false);
+    const result = await emitNotificationSignal({
+      ...params,
+      attentionHints: { ...params.attentionHints, urgency: "high" },
+    });
+    expect(result.selectedChannels).toEqual(["vellum"]);
+    expect(isPlatformClientConfiguredMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("preserves preferred external selections while adding the platform default", async () => {
+    evaluateSignalMock.mockResolvedValue(decision(["vellum", "telegram"]));
+    const result = await emitNotificationSignal(params);
+    expect(result.selectedChannels).toEqual(["vellum", "telegram", "platform"]);
+  });
+
+  test.each(["deduplicated", "source_active"])(
+    "does not resolve candidates for %s signals",
+    async (scenario) => {
+      if (scenario === "deduplicated") {
+        createEventMock.mockReturnValue(null);
+      }
+      await emitNotificationSignal({
+        ...params,
+        attentionHints: {
+          ...params.attentionHints,
+          visibleInSourceNow: scenario === "source_active",
+        },
+      });
+      expect(resolveAssistantInitiatedThreadMock).not.toHaveBeenCalled();
+      expect(dispatchDecisionMock).not.toHaveBeenCalled();
+    },
+  );
+});

package/src/__tests__/llm-catalog-parity.test.ts

@@ -390,9 +390,9 @@ describe("LLM catalog parity: daemon vs client", () => {
     });
   });
 
-  test("Fireworks catalog includes GLM 5.2", () => {
+  test("Fireworks catalog includes GLM 5.3", () => {
     expect(
-      isModelInCatalog("fireworks", "accounts/fireworks/models/glm-5p2"),
+      isModelInCatalog("fireworks", "accounts/fireworks/models/glm-5p3"),
     ).toBe(true);
 
     const fireworks = PROVIDER_CATALOG.find(
@@ -400,10 +400,10 @@ describe("LLM catalog parity: daemon vs client", () => {
     );
     expect(
       fireworks?.models.find(
-        (model) => model.id === "accounts/fireworks/models/glm-5p2",
+        (model) => model.id === "accounts/fireworks/models/glm-5p3",
       ),
     ).toMatchObject({
-      displayName: "GLM 5.2",
+      displayName: "GLM 5.3",
       contextWindowTokens: 1040000,
       maxOutputTokens: 131072,
       supportsToolUse: true,

package/src/__tests__/llm-schema.test.ts

@@ -198,7 +198,7 @@ describe("LLMSchema", () => {
       profiles: {
         "glm-default": {
           provider: "vellum",
-          model: "accounts/fireworks/models/glm-5p2",
+          model: "accounts/fireworks/models/glm-5p3",
         },
       },
       activeProfile: "glm-default",

package/src/__tests__/openai-provider.test.ts

@@ -1960,10 +1960,10 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
     lastCreateParams = null;
   });
 
-  test('DeepSeek V4 Pro accepts "max" unclamped', async () => {
+  test('DeepSeek V4.1 Flash accepts "max" unclamped', async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/deepseek-v4-pro-0813",
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -1972,10 +1972,10 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
     expect(lastCreateParams!.reasoning_effort).toBe("max");
   });
 
-  test('DeepSeek V4 Pro accepts "xhigh" unclamped', async () => {
+  test('DeepSeek V4.1 Flash accepts "xhigh" unclamped', async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/deepseek-v4-pro-0813",
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -1984,10 +1984,10 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
     expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
   });
 
-  test('Kimi K2.6 clamps "xhigh"/"max" down to "high"', async () => {
+  test('MiniMax M3 clamps "xhigh"/"max" down to "high"', async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/kimi-k2p6",
+      "accounts/fireworks/models/minimax-m3",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -2016,7 +2016,7 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
   test("effort below ceiling is forwarded verbatim", async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/deepseek-v4-pro-0813",
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -2028,7 +2028,7 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
   test('effort: "none" passes through regardless of ceiling', async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/kimi-k2p6",
+      "accounts/fireworks/models/minimax-m3",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -2040,13 +2040,13 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
   test("model override picks ceiling from runtime model, not constructor model", async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/kimi-k2p6",
+      "accounts/fireworks/models/minimax-m3",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
       config: {
         effort: "max",
-        model: "accounts/fireworks/models/deepseek-v4-pro-0813",
+        model: "accounts/fireworks/models/deepseek-v4p1-flash",
       },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("max");
@@ -2111,7 +2111,7 @@ describe("FireworksProvider sparse reasoning_effort support (GLM 5.3)", () => {
 
   test("models without supportedEfforts are unaffected", async () => {
     expect(
-      await send("accounts/fireworks/models/deepseek-v4-pro-0813", "medium"),
+      await send("accounts/fireworks/models/deepseek-v4p1-flash", "medium"),
     ).toBe("medium");
   });
 });

package/src/__tests__/pricing.test.ts

@@ -10,6 +10,17 @@ import {
 } from "../util/pricing.js";
 
 describe("resolvePricing", () => {
+  test.each([
+    ["accounts/fireworks/models/glm-5p2", 1.4 + 4.4],
+    ["accounts/fireworks/models/kimi-k2p6", 0.95 + 4.0],
+    ["accounts/fireworks/models/deepseek-v4-pro-0813", 1.32 + 3.96],
+    ["accounts/fireworks/models/deepseek-v4-flash-0731", 0.14 + 0.28],
+  ])("prices stored usage for retired Fireworks model %s", (model, cost) => {
+    const result = resolvePricing("fireworks", model, 1_000_000, 1_000_000);
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBeCloseTo(cost, 10);
+  });
+
   describe("Anthropic models", () => {
     test("returns priced for claude-opus-4-6", () => {
       const result = resolvePricing(

package/src/__tests__/workspace-migration-133-collapse-provider-connections.test.ts

@@ -100,7 +100,7 @@ describe("133-collapse-provider-connections migration", () => {
             source: "user",
             provider: "fireworks",
             provider_connection: "vellum",
-            model: "accounts/fireworks/models/glm-5p2",
+            model: "accounts/fireworks/models/minimax-m3",
           },
         },
       },
@@ -257,7 +257,7 @@ describe("133-collapse-provider-connections migration", () => {
           encoded: {
             source: "user",
             provider: "vellum",
-            model: "fireworks/accounts/fireworks/models/glm-5p2",
+            model: "fireworks/accounts/fireworks/models/minimax-m3",
           },
         },
       },
@@ -272,7 +272,7 @@ describe("133-collapse-provider-connections migration", () => {
     expect(llm.profiles.encoded).toEqual({
       source: "user",
       provider: "vellum",
-      model: "accounts/fireworks/models/glm-5p2",
+      model: "accounts/fireworks/models/minimax-m3",
     });
   });