@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

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__/list-messages-client-message-id.test.ts

@@ -8,6 +8,7 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { MESSAGE_KEYS } from "../i18n/index.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Keep the memory system off so addMessage skips indexing side effects.
@@ -31,6 +32,7 @@ function resetTables() {
 
 interface MessagePayload {
   role: string;
+  textSegments?: string[];
   clientMessageId?: string;
 }
 
@@ -59,6 +61,47 @@ describe("handleListMessages clientMessageId", () => {
     expect(body.messages[0].clientMessageId).toBe("nonce-abc");
   });
 
+  test("localizes persisted assistant keys without rewriting legacy text", async () => {
+    const localizedConv = createConversation();
+    await addMessage(
+      localizedConv.id,
+      "assistant",
+      JSON.stringify([
+        {
+          type: "text",
+          text: MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP,
+        },
+      ]),
+      { skipIndexing: true },
+    );
+
+    const localizedResponse = await handleListMessages({
+      queryParams: { conversationId: localizedConv.id },
+      headers: { "accept-language": "es" },
+    });
+    const localizedBody = localizedResponse as { messages: MessagePayload[] };
+    expect(localizedBody.messages[0]?.textSegments).toEqual([
+      "Me detuve después de varias llamadas de herramienta con formato incorrecto para evitar que esta conversación creciera indefinidamente. Inténtalo de nuevo o cambia de modelo si el problema continúa.",
+    ]);
+
+    const legacyConv = createConversation();
+    const legacy =
+      "I stopped after repeated malformed tool calls to keep this conversation from growing indefinitely. Please try again, or switch models if the problem continues.";
+    await addMessage(
+      legacyConv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: legacy }]),
+      { skipIndexing: true },
+    );
+
+    const legacyResponse = await handleListMessages({
+      queryParams: { conversationId: legacyConv.id },
+      headers: { "accept-language": "es" },
+    });
+    const legacyBody = legacyResponse as { messages: MessagePayload[] };
+    expect(legacyBody.messages[0]?.textSegments).toEqual([legacy]);
+  });
+
   test("omits clientMessageId when the row was persisted without one", async () => {
     // GIVEN a user message persisted without a client nonce (e.g. a channel send)
     const conv = createConversation();

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

@@ -1178,6 +1178,33 @@ describe("OpenAIProvider", () => {
     });
   });
 
+  test("bounds malformed arguments in the diagnostic raw response only", async () => {
+    const raw = '{"content":"' + "x".repeat(1_000);
+    fakeChunks = [
+      ...toolCallChunks([{ id: "call_large_bad", name: "test", args: raw }]),
+      usageChunk(10, 5),
+    ];
+
+    const result = await provider.sendMessage([userMsg("test")]);
+
+    expect(result.content[0]).toEqual({
+      type: "tool_use",
+      id: "call_large_bad",
+      name: "test",
+      input: { _raw: raw },
+    });
+    const rawResponse = result.rawResponse as {
+      choices: Array<{
+        message: {
+          tool_calls: Array<{ function: { arguments: string } }>;
+        };
+      }>;
+    };
+    expect(
+      rawResponse.choices[0]!.message.tool_calls[0]!.function.arguments,
+    ).toBe(raw.slice(0, 200) + "…");
+  });
+
   // -----------------------------------------------------------------------
   // stream_options and model
   // -----------------------------------------------------------------------
@@ -1960,10 +1987,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 +1999,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 +2011,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 +2043,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 +2055,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 +2067,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 +2138,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__/skill-execute-input.test.ts

@@ -188,6 +188,17 @@ describe("recoverSkillExecuteEnvelope", () => {
     expect(recoverSkillExecuteEnvelope(wrapped)).toBe(wrapped);
   });
 
+  test("keeps recovered JSON wrapped when it lacks a string tool name", () => {
+    for (const raw of [
+      JSON.stringify({ input: { content: "hi" }, activity: "x" }),
+      JSON.stringify({ tool: 42, input: {}, activity: "x" }),
+      JSON.stringify(["document_update"]),
+    ]) {
+      const wrapped = { _raw: raw };
+      expect(recoverSkillExecuteEnvelope(wrapped)).toBe(wrapped);
+    }
+  });
+
   test("passes a normal envelope through untouched", () => {
     const envelope = {
       tool: "document_update",

package/src/__tests__/tool-approval-handler.test.ts

@@ -1357,6 +1357,10 @@ describe("ToolApprovalHandler / unparseable tool args gate", () => {
     }
     expect(result.result.content).not.toContain(raw);
     expect(result.result.content).toContain("…");
+    expect(auditCalls.error).toHaveLength(1);
+    expect(auditCalls.error[0].input).toEqual({
+      _raw: raw.slice(0, 200) + "…",
+    });
   });
 
   test("legitimate input containing a _raw field among others is not rejected", async () => {

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -341,6 +341,32 @@ describe("tool preview lifecycle", () => {
       expect((emitted as any).conversationId).toBe("test-session-id");
     });
 
+    test("caps cumulative app preview payloads and stops forwarding growth", () => {
+      const collector = createEventCollector();
+      const deps = createMockDeps({ onEvent: collector.onEvent });
+      const accumulatedJson = '{"code":"' + "x".repeat(300_000);
+
+      handleInputJsonDelta(state, deps, {
+        type: "input_json_delta",
+        toolName: "app_create",
+        toolUseId: "toolu_large_app",
+        accumulatedJson,
+      });
+      handleInputJsonDelta(state, deps, {
+        type: "input_json_delta",
+        toolName: "app_create",
+        toolUseId: "toolu_large_app",
+        accumulatedJson: accumulatedJson + "more",
+      });
+
+      expect(collector.events).toHaveLength(1);
+      const emitted = collector.events[0] as Extract<
+        AssistantEvent,
+        { type: "tool_input_delta" }
+      >;
+      expect(emitted.content).toBe(accumulatedJson.slice(0, 256_000));
+    });
+
     test("a streaming ui_show visual announces its surface exactly once", () => {
       const collector = createEventCollector();
       const deps = createMockDeps({ onEvent: collector.onEvent });

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