@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292019.a6f6d85

package/src/__tests__/identity-routes.test.ts

@@ -166,6 +166,7 @@ describe("identity routes — health endpoint", () => {
         memoryOptOut: true,
         retryLastTurn: true,
         appPins: true,
+        chatsSettings: true,
       });
 
       // Profiler should either be absent or show enabled: false
@@ -492,9 +493,9 @@ describe("identity routes — /readyz readiness gate", () => {
     expect(body.ready).toBe(false);
     expect(body.reason).toBe("db_migrations_failed");
     expect((body.dbMigrations as Record<string, unknown>).state).toBe("failed");
-    expect((body.dbMigrations as Record<string, unknown>).failedMigrations).toEqual(
-      [{ name: "flakyStep", error: "transient failure" }],
-    );
+    expect(
+      (body.dbMigrations as Record<string, unknown>).failedMigrations,
+    ).toEqual([{ name: "flakyStep", error: "transient failure" }]);
   });
 
   test("returns 200 even if CES is down", async () => {

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__/notification-platform-adapter.test.ts

@@ -1,11 +1,14 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { saveRawConfig } from "../config/loader.js";
+
 // ── Mock logger ──────────────────────────────────────────────────────────────
 
 // ── Mock sleep so retry tests don't slow down the suite ──────────────────────
 
+let onRetrySleep: () => Promise<void> = async () => {};
 mock.module("../util/retry.js", () => ({
-  sleep: async (_ms: number): Promise<void> => {},
+  sleep: async (_ms: number): Promise<void> => onRetrySleep(),
   isRetryableStatus: (status: number): boolean =>
     status === 429 || status >= 500,
   isRetryableNetworkError: (error: unknown): boolean => {
@@ -41,10 +44,12 @@ const fetchResponses: Array<{ ok: boolean; status: number; body?: string }> =
   [];
 const fetchErrors: Error[] = [];
 let clientAvailable = true;
+let onClientCreation: () => Promise<void> = async () => {};
 
 mock.module("../platform/client.js", () => ({
   VellumPlatformClient: {
     create: async () => {
+      await onClientCreation();
       if (!clientAvailable) {
         return null;
       }
@@ -117,12 +122,89 @@ function makeDestination(
 
 describe("PlatformPushAdapter", () => {
   beforeEach(() => {
+    saveRawConfig({});
     fetchCalls.length = 0;
     fetchResponses.length = 0;
     fetchErrors.length = 0;
     clientAvailable = true;
+    onRetrySleep = async () => {};
+    onClientCreation = async () => {};
+  });
+
+  test("skips a disabled chat reply without sending a native push", async () => {
+    saveRawConfig({ notifications: { newMessageEnabled: false } });
+    const result = await new PlatformPushAdapter().send(
+      makePayload({ sourceEventName: "chat.assistant_reply" }),
+      makeDestination(),
+    );
+    expect(result).toMatchObject({
+      success: false,
+      skipped: true,
+      remotePushAccepted: false,
+    });
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("rechecks the setting after platform client creation", async () => {
+    onClientCreation = async () => {
+      saveRawConfig({ notifications: { newMessageEnabled: false } });
+    };
+    const result = await new PlatformPushAdapter().send(
+      makePayload({ sourceEventName: "chat.assistant_reply" }),
+      makeDestination(),
+    );
+    expect(result).toMatchObject({
+      success: false,
+      skipped: true,
+      remotePushAccepted: false,
+    });
+    expect(fetchCalls).toHaveLength(0);
   });
 
+  test.each([false, true])(
+    "stops retries after disabling replies (accepted push: %s)",
+    async (accepted) => {
+      fetchResponses.push({
+        ok: false,
+        status: 503,
+        body: accepted ? '{"accepted_platforms":["ios"]}' : "{}",
+      });
+      onRetrySleep = async () => {
+        saveRawConfig({ notifications: { newMessageEnabled: false } });
+      };
+      const result = await new PlatformPushAdapter().send(
+        makePayload({ sourceEventName: "chat.assistant_reply" }),
+        makeDestination(),
+      );
+      expect(fetchCalls).toHaveLength(1);
+      expect(result).toMatchObject({
+        success: accepted,
+        skipped: !accepted,
+        remotePushAccepted: accepted,
+        remotePushPlatforms: accepted ? ["ios"] : undefined,
+      });
+    },
+  );
+
+  test.each([
+    "schedule.result",
+    "schedule.notify",
+    "guardian.question",
+    "activity.failed",
+    "chat.assistant_reply.extra",
+  ])(
+    "keeps %s native push enabled when ordinary reply alerts are off",
+    async (sourceEventName) => {
+      saveRawConfig({ notifications: { newMessageEnabled: false } });
+      const result = await new PlatformPushAdapter().send(
+        makePayload({ sourceEventName }),
+        makeDestination(),
+      );
+      expect(result.success).toBe(true);
+      expect(fetchCalls).toHaveLength(1);
+    },
+  );
+
   test("channel is 'platform'", () => {
     expect(new PlatformPushAdapter().channel).toBe("platform");
   });

package/src/__tests__/oauth2-gateway-transport.test.ts

@@ -48,6 +48,8 @@ let mockOAuthCallbackUrl = "";
 // getPublicBaseUrl.
 mock.module("../inbound/public-ingress-urls.js", () => ({
   getOAuthCallbackUrl: () => mockOAuthCallbackUrl,
+  getMcpOAuthClientMetadataUrl: () =>
+    "http://localhost/oauth/client-metadata.json",
   getPublicBaseUrl: (config?: { ingress?: { publicBaseUrl?: string } }) => {
     const url = config?.ingress?.publicBaseUrl ?? "";
     if (!url) {

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__/public-ingress-urls.test.ts

@@ -6,6 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { setIngressPublicBaseUrl } from "../config/env.js";
 import { IngressConfigSchema } from "../config/schemas/ingress.js";
 import {
+  getMcpOAuthClientMetadataUrl,
   getOAuthCallbackUrl,
   getPublicBaseUrl,
   getTelegramWebhookUrl,
@@ -307,6 +308,31 @@ describe("getOAuthCallbackUrl", () => {
     });
     expect(url).toBe("https://example.com/webhooks/oauth/callback");
   });
+
+  test("canonicalizes the base before building OAuth URLs", () => {
+    const config = {
+      ingress: {
+        publicBaseUrl: "https://EXAMPLE.com:443/a/../assistant-123///",
+      },
+    };
+
+    expect(getOAuthCallbackUrl(config)).toBe(
+      "https://example.com/assistant-123/webhooks/oauth/callback",
+    );
+    expect(getMcpOAuthClientMetadataUrl(config)).toBe(
+      "https://example.com/assistant-123/oauth/client-metadata.json",
+    );
+  });
+});
+
+describe("getMcpOAuthClientMetadataUrl", () => {
+  test("builds the public metadata URL", () => {
+    expect(
+      getMcpOAuthClientMetadataUrl({
+        ingress: { publicBaseUrl: "https://example.com/assistant-123/" },
+      }),
+    ).toBe("https://example.com/assistant-123/oauth/client-metadata.json");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/retry-thinking-tool-choice.test.ts

@@ -144,6 +144,53 @@ describe("retry normalization: thinking + forced tool_choice", () => {
     expect(lastConfig()?.thinking).toEqual({ type: "adaptive" });
   });
 
+  for (const [providerName, model] of [
+    ["anthropic", "claude-sonnet-5-5"],
+    ["anthropic", "claude-opus-5-5"],
+    ["openrouter", "anthropic/claude-sonnet-5.5"],
+    ["vercel-ai-gateway", "anthropic/claude-sonnet-5.5"],
+  ] as const) {
+    test(`downgrades forced tool_choice to auto for ${providerName} ${model}`, async () => {
+      // These models always reason and reject forced tool use, so stripping
+      // `thinking` is not enough: the forced choice itself has to go.
+      setLlmConfig({
+        callSites: {
+          memoryExtraction: { provider: providerName, model },
+        },
+      });
+      const { provider, lastConfig } = makePipeline(providerName);
+      await provider.sendMessage([userMessage], {
+        config: {
+          callSite: "memoryExtraction",
+          tool_choice: { type: "tool", name: "extract_graph_diff" },
+        },
+      });
+      expect(lastConfig()?.tool_choice).toEqual({ type: "auto" });
+    });
+  }
+
+  test("keeps forced tool_choice for an adaptive-only model off the Anthropic wire", async () => {
+    setLlmConfig({
+      callSites: {
+        memoryExtraction: {
+          provider: "fireworks",
+          model: "accounts/fireworks/models/glm-5p3",
+        },
+      },
+    });
+    const { provider, lastConfig } = makePipeline("fireworks");
+    await provider.sendMessage([userMessage], {
+      config: {
+        callSite: "memoryExtraction",
+        tool_choice: { type: "tool", name: "extract_graph_diff" },
+      },
+    });
+    expect(lastConfig()?.tool_choice).toEqual({
+      type: "tool",
+      name: "extract_graph_diff",
+    });
+  });
+
   test("preserves explicit thinking: disabled with forced tool_choice", async () => {
     // Callers like the retriever explicitly set thinking: { type: "disabled" }
     // alongside forced tool_choice. This should pass through unchanged since

package/src/__tests__/usage-attribution.test.ts

@@ -109,6 +109,37 @@ describe("resolveUsageAttribution", () => {
     expectResolvedProviderModelMatchesResolver("mainAgent", "pinned");
   });
 
+  test("reports an override the Auto router chose as the auto source", () => {
+    setLlmConfig({
+      profiles: {
+        active: { provider: "openai", model: "gpt-5.4" },
+        routed: { provider: "gemini", model: "gemini-3-pro" },
+      },
+      activeProfile: "active",
+    });
+
+    const snapshot = resolveUsageAttribution({
+      callSite: "mainAgent",
+      overrideProfile: "routed",
+      overrideProfileOrigin: "auto",
+    });
+
+    expect(snapshot).toMatchObject({
+      appliedProfile: "routed",
+      profileSource: "auto",
+      resolvedProvider: "gemini",
+      resolvedModel: "gemini-3-pro",
+    });
+    // The origin only relabels an override that actually won.
+    expect(
+      resolveUsageAttribution({
+        callSite: "mainAgent",
+        overrideProfile: "missing",
+        overrideProfileOrigin: "auto",
+      }).profileSource,
+    ).toBe("active");
+  });
+
   test("resolves call-site profile attribution", () => {
     setLlmConfig({
       profiles: {

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",
     });
   });