@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/oauth-provider-visibility.test.ts

@@ -21,13 +21,13 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: () => Promise.resolve(undefined),
 }));
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
-import { resetDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { resetTestTables } from "../memory/raw-query.js";
 import { listProviders, seedProviders } from "../oauth/oauth-store.js";
 import { isProviderVisible } from "../oauth/provider-visibility.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 initializeDb();
 
@@ -38,15 +38,15 @@ function makeConfig(): AssistantConfig {
 
 beforeEach(() => {
   resetTestTables("oauth_connections", "oauth_apps", "oauth_providers");
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 describe("isProviderVisible", () => {
@@ -70,7 +70,7 @@ describe("isProviderVisible", () => {
   });
 
   test("returns true when featureFlag is set and the flag is enabled", () => {
-    _setOverridesForTesting({ "test-gate": true });
+    setOverridesForTesting({ "test-gate": true });
 
     seedProviders([
       {
@@ -93,7 +93,7 @@ describe("isProviderVisible", () => {
   });
 
   test("returns false when featureFlag is set and the flag is disabled", () => {
-    _setOverridesForTesting({ "test-gate": false });
+    setOverridesForTesting({ "test-gate": false });
 
     seedProviders([
       {
@@ -115,7 +115,7 @@ describe("isProviderVisible", () => {
   });
 
   test("listProviders returns all providers but isProviderVisible filters gated ones when flag is disabled", () => {
-    _setOverridesForTesting({ "test-gate": false });
+    setOverridesForTesting({ "test-gate": false });
 
     seedProviders([
       {

package/src/__tests__/oauth-store.test.ts

@@ -42,7 +42,7 @@ mock.module("../oauth/credential-token-resolver.js", () => ({
 
 import { eq } from "drizzle-orm";
 
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { migrateOAuthProvidersTokenAuthMethodDefault } from "../memory/migrations/216-oauth-providers-token-auth-method.js";
@@ -70,6 +70,7 @@ import {
   upsertApp,
 } from "../oauth/oauth-store.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { getMockFetchCalls, mockFetch, resetMockFetch } from "./mock-fetch.js";
 
 initializeDb();
@@ -103,7 +104,7 @@ beforeEach(() => {
 });
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/onboarding-template-contract.test.ts

@@ -69,6 +69,18 @@ describe("onboarding template contracts", () => {
       expect(bootstrap).toContain("One-shot");
     });
 
+    test("offers assistant migration during low-signal first openings", () => {
+      expect(bootstrap).toContain("## Assistant migration");
+      expect(bootstrap).toContain("onboarding self-introduction");
+      expect(bootstrap).toContain("treat it as the real first user turn");
+      expect(bootstrap).toContain(
+        "If the first real user turn is only a greeting",
+      );
+      expect(bootstrap).toContain("that first response is the natural opening");
+      expect(bootstrap).toContain("assistant-migration");
+      expect(bootstrap).toContain("do not load or activate");
+    });
+
     test("does not contain personality quiz references", () => {
       expect(bootstrap).not.toMatch(/show.*personality quiz/i);
       expect(bootstrap).not.toMatch(/present.*personality quiz/i);
@@ -111,8 +123,9 @@ describe("onboarding template contracts", () => {
       expect(identity).toContain("**Emoji:**");
     });
 
-    test("contains parsed field format guidance", () => {
-      expect(identity).toContain("parsed by the app");
+    test("does not invite assistant-owned identity restructuring", () => {
+      expect(identity).not.toContain("This file is yours");
+      expect(identity).not.toContain("parsed by the app");
     });
   });
 

package/src/__tests__/openai-image-service.test.ts

@@ -351,6 +351,23 @@ describe("mapOpenAIError", () => {
     expect(msg).toContain("Rate limit");
   });
 
+  test("maps 402 status to a non-retryable out-of-credits message", () => {
+    const msg = mapOpenAIError(new FakeAPIError(402, "payment required"));
+    expect(msg).toContain("out of credits");
+    expect(msg).not.toContain("Please try again");
+  });
+
+  test("maps insufficient_quota (reported as 429) to out-of-credits message", () => {
+    const msg = mapOpenAIError(
+      new FakeAPIError(
+        429,
+        "You exceeded your current quota, please check your plan and billing details. (insufficient_quota)",
+      ),
+    );
+    expect(msg).toContain("out of credits");
+    expect(msg).not.toContain("Rate limit");
+  });
+
   test("maps 500 status to server error message", () => {
     const msg = mapOpenAIError(new FakeAPIError(500, "internal"));
     expect(msg).toContain("temporarily unavailable");

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

@@ -105,7 +105,10 @@ mock.module("openai", () => ({
 import { FireworksProvider } from "../providers/fireworks/client.js";
 import { MinimaxProvider } from "../providers/minimax/client.js";
 import { OllamaProvider } from "../providers/ollama/client.js";
-import { OpenAIChatCompletionsProvider } from "../providers/openai/chat-completions-provider.js";
+import {
+  EMPTY_ASSISTANT_TURN_PLACEHOLDER,
+  OpenAIChatCompletionsProvider,
+} from "../providers/openai/chat-completions-provider.js";
 import { OpenAIProvider } from "../providers/openai/client.js";
 import { OpenRouterProvider } from "../providers/openrouter/client.js";
 
@@ -379,8 +382,6 @@ describe("OpenAIProvider", () => {
     const events: ProviderEvent[] = [];
     await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-      undefined,
-      undefined,
       { onEvent: (e) => events.push(e) },
     );
 
@@ -422,7 +423,7 @@ describe("OpenAIProvider", () => {
     ];
 
     const events: ProviderEvent[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (e) => events.push(e),
     });
 
@@ -470,14 +471,9 @@ describe("OpenAIProvider", () => {
     ];
 
     const events: ProviderEvent[] = [];
-    const result = await provider.sendMessage(
-      [userMsg("Hi")],
-      undefined,
-      undefined,
-      {
-        onEvent: (e) => events.push(e),
-      },
-    );
+    const result = await provider.sendMessage([userMsg("Hi")], {
+      onEvent: (e) => events.push(e),
+    });
 
     expect(result.content).toHaveLength(2);
     expect(result.content[0]).toEqual({
@@ -504,14 +500,9 @@ describe("OpenAIProvider", () => {
     ];
 
     const events: ProviderEvent[] = [];
-    const result = await provider.sendMessage(
-      [userMsg("Hi")],
-      undefined,
-      undefined,
-      {
-        onEvent: (e) => events.push(e),
-      },
-    );
+    const result = await provider.sendMessage([userMsg("Hi")], {
+      onEvent: (e) => events.push(e),
+    });
 
     expect(result.content).toHaveLength(2);
     expect(result.content[0]).toEqual({
@@ -544,8 +535,7 @@ describe("OpenAIProvider", () => {
 
     await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-      undefined,
-      "You are a helpful assistant.",
+      { systemPrompt: "You are a helpful assistant." },
     );
 
     const messages = lastCreateParams!.messages as Array<
@@ -578,7 +568,7 @@ describe("OpenAIProvider", () => {
 
     await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "Read /tmp/test" }] }],
-      tools,
+      { tools: tools },
     );
 
     const sentTools = lastCreateParams!.tools as Array<Record<string, unknown>>;
@@ -903,8 +893,6 @@ describe("OpenAIProvider", () => {
 
     await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-      undefined,
-      undefined,
       { config: { max_tokens: 64000 } },
     );
 
@@ -947,8 +935,6 @@ describe("OpenAIProvider", () => {
 
     await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-      undefined,
-      undefined,
       { signal: controller.signal },
     );
 
@@ -967,8 +953,6 @@ describe("OpenAIProvider", () => {
 
     await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-      undefined,
-      undefined,
       { signal: controller.signal },
     );
 
@@ -1024,8 +1008,6 @@ describe("OpenAIProvider", () => {
     try {
       await provider.sendMessage(
         [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-        undefined,
-        undefined,
         { signal: controller.signal },
       );
       expect(true).toBe(false); // should not reach
@@ -1044,8 +1026,6 @@ describe("OpenAIProvider", () => {
     try {
       await provider.sendMessage(
         [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-        undefined,
-        undefined,
         { signal: controller.signal },
       );
       expect(true).toBe(false);
@@ -1063,8 +1043,6 @@ describe("OpenAIProvider", () => {
     try {
       await provider.sendMessage(
         [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-        undefined,
-        undefined,
         { signal: controller.signal },
       );
       expect(true).toBe(false);
@@ -1412,7 +1390,7 @@ describe("effort config passthrough", () => {
   ): Provider {
     return {
       name,
-      async sendMessage(_messages, _tools, _systemPrompt, options) {
+      async sendMessage(_messages: Message[], options?: SendMessageOptions) {
         onCall(options);
         return makeResponse();
       },
@@ -1426,7 +1404,7 @@ describe("effort config passthrough", () => {
     });
     const retry = new RetryProvider(inner);
 
-    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await retry.sendMessage(DUMMY_MESSAGES, {
       config: { effort: "high" },
     });
 
@@ -1441,7 +1419,7 @@ describe("effort config passthrough", () => {
     });
     const retry = new RetryProvider(inner);
 
-    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await retry.sendMessage(DUMMY_MESSAGES, {
       config: { effort: "medium" },
     });
 
@@ -1456,7 +1434,7 @@ describe("effort config passthrough", () => {
     });
     const retry = new RetryProvider(inner);
 
-    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await retry.sendMessage(DUMMY_MESSAGES, {
       config: { effort: "low" },
     });
 
@@ -1471,7 +1449,7 @@ describe("effort config passthrough", () => {
     });
     const retry = new RetryProvider(inner);
 
-    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await retry.sendMessage(DUMMY_MESSAGES, {
       config: { effort: "high" },
     });
 
@@ -1486,7 +1464,7 @@ describe("effort config passthrough", () => {
     });
     const retry = new RetryProvider(inner);
 
-    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await retry.sendMessage(DUMMY_MESSAGES, {
       config: { effort: "high" },
     });
 
@@ -1501,7 +1479,7 @@ describe("effort config passthrough", () => {
     });
     const retry = new RetryProvider(inner);
 
-    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await retry.sendMessage(DUMMY_MESSAGES, {
       config: {
         thinking: { enabled: true, budgetTokens: 10000 },
         effort: "high",
@@ -1520,7 +1498,7 @@ describe("effort config passthrough", () => {
     });
     const retry = new RetryProvider(inner);
 
-    await retry.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await retry.sendMessage(DUMMY_MESSAGES, {
       config: {
         thinking: { type: "adaptive" },
       },
@@ -1546,7 +1524,7 @@ describe("OpenRouterProvider reasoning", () => {
 
   test("sends reasoning.enabled=true with default detailed summary when thinking config is present", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { thinking: { type: "adaptive" } },
     });
 
@@ -1557,37 +1535,37 @@ describe("OpenRouterProvider reasoning", () => {
     });
   });
 
-  test("sends reasoning.enabled=false when thinking is explicitly disabled", async () => {
+  test("omits reasoning when thinking is explicitly disabled", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { thinking: { type: "disabled" } },
     });
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
-  test("sends reasoning.enabled=false when thinking config is absent", async () => {
+  test("omits reasoning when thinking config is absent", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: {},
     });
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
-  test("sends reasoning.enabled=false when no options are provided", async () => {
+  test("omits reasoning when no options are provided", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     await provider.sendMessage([userMsg("hi")]);
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
   test("sends OpenRouter app-attribution headers on OpenAI-compatible requests", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: {
         usageAttributionHeaders: {
           "Vellum-Organization-Id": "org-123",
@@ -1609,12 +1587,39 @@ describe("OpenRouterProvider reasoning", () => {
     expect(lastCreateParams).not.toHaveProperty("usageAttributionHeaders");
   });
 
+  test("backfills placeholder content for a reasoning-only assistant turn", async () => {
+    const provider = new OpenRouterProvider("or-key", "deepseek/deepseek-chat");
+    await provider.sendMessage([
+      userMsg("question"),
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "truncated reasoning", signature: "" },
+        ],
+      },
+    ]);
+
+    const sent = lastCreateParams!.messages as Array<{
+      role: string;
+      content: string | null;
+      reasoning?: string;
+      tool_calls?: unknown;
+    }>;
+    const assistantMsg = sent.find((m) => m.role === "assistant")!;
+    // DeepSeek via OpenRouter rejects an assistant message with neither content
+    // nor tool_calls, so the reasoning-only turn is backfilled with the sentinel
+    // while the reasoning itself travels in the separate `reasoning` field.
+    expect(assistantMsg.content).toBe(EMPTY_ASSISTANT_TURN_PLACEHOLDER);
+    expect(assistantMsg.tool_calls).toBeUndefined();
+    expect(assistantMsg.reasoning).toBe("truncated reasoning");
+  });
+
   test("RetryProvider + OpenRouterProvider enables thinking end-to-end", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     const retry = new RetryProvider(provider);
 
     // thinking enabled at loop-level → config.thinking set
-    await retry.sendMessage([userMsg("hi")], undefined, undefined, {
+    await retry.sendMessage([userMsg("hi")], {
       config: { thinking: { type: "adaptive" } },
     });
     expect(lastCreateParams!.reasoning).toEqual({
@@ -1623,20 +1628,19 @@ describe("OpenRouterProvider reasoning", () => {
     });
   });
 
-  test("RetryProvider + OpenRouterProvider disables thinking end-to-end", async () => {
+  test("RetryProvider + OpenRouterProvider omits reasoning when thinking disabled", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     const retry = new RetryProvider(provider);
 
-    // thinking disabled at loop-level can arrive as an explicit disabled config.
-    await retry.sendMessage([userMsg("hi")], undefined, undefined, {
+    await retry.sendMessage([userMsg("hi")], {
       config: { thinking: { type: "disabled" } },
     });
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
   test("nests effort under reasoning and omits top-level reasoning_effort", async () => {
     const provider = new OpenRouterProvider("or-key", "moonshotai/kimi-k2.6");
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { thinking: { enabled: true }, effort: "max" },
     });
 
@@ -1710,7 +1714,8 @@ describe("OpenAIProvider reasoning_effort", () => {
   });
 
   test('effort: "low" maps to reasoning_effort: "low"', async () => {
-    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "low" },
     });
     expect(lastCreateParams).toBeTruthy();
@@ -1718,35 +1723,40 @@ describe("OpenAIProvider reasoning_effort", () => {
   });
 
   test('effort: "medium" maps to reasoning_effort: "medium"', async () => {
-    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "medium" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("medium");
   });
 
   test('effort: "high" maps to reasoning_effort: "high"', async () => {
-    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "high" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("high");
   });
 
   test('effort: "max" maps to reasoning_effort: "xhigh"', async () => {
-    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "max" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
   });
 
   test('effort: "xhigh" maps to reasoning_effort: "xhigh"', async () => {
-    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "xhigh" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
   });
 
   test("no effort config means no reasoning_effort in params", async () => {
-    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: {},
     });
     expect(lastCreateParams).toBeTruthy();
@@ -1757,7 +1767,8 @@ describe("OpenAIProvider reasoning_effort", () => {
     // OpenAI defaults `reasoning_effort` to "medium" when the field is
     // omitted, so the user's opt-out is only honored when we send the
     // explicit "none" value on the wire.
-    await provider.sendMessage([userMsg("hi")], undefined, "system", {
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "none" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("none");
@@ -1767,7 +1778,8 @@ describe("OpenAIProvider reasoning_effort", () => {
     const providerWithExtra = new OpenAIProvider("test-key", "gpt-5", {
       extraCreateParams: { reasoning_effort: "medium" },
     });
-    await providerWithExtra.sendMessage([userMsg("hi")], undefined, "system", {
+    await providerWithExtra.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: {},
     });
     expect(lastCreateParams!.reasoning_effort).toBe("medium");
@@ -1777,15 +1789,18 @@ describe("OpenAIProvider reasoning_effort", () => {
     const capped = new OpenAIProvider("test-key", "gpt-5", {
       maxReasoningEffort: "high",
     });
-    await capped.sendMessage([userMsg("hi")], undefined, "system", {
+    await capped.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "xhigh" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("high");
-    await capped.sendMessage([userMsg("hi")], undefined, "system", {
+    await capped.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "max" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("high");
-    await capped.sendMessage([userMsg("hi")], undefined, "system", {
+    await capped.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "medium" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("medium");
@@ -1795,11 +1810,13 @@ describe("OpenAIProvider reasoning_effort", () => {
     const uncapped = new OpenAIProvider("test-key", "gpt-5", {
       maxReasoningEffort: "max",
     });
-    await uncapped.sendMessage([userMsg("hi")], undefined, "system", {
+    await uncapped.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "max" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("max");
-    await uncapped.sendMessage([userMsg("hi")], undefined, "system", {
+    await uncapped.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "xhigh" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
@@ -1817,7 +1834,8 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
       "fw-key",
       "accounts/fireworks/models/deepseek-v4-pro",
     );
-    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "max" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("max");
@@ -1828,7 +1846,8 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
       "fw-key",
       "accounts/fireworks/models/deepseek-v4-pro",
     );
-    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "xhigh" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
@@ -1839,11 +1858,13 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
       "fw-key",
       "accounts/fireworks/models/kimi-k2p6",
     );
-    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "xhigh" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("high");
-    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "max" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("high");
@@ -1854,7 +1875,8 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
       "fw-key",
       "accounts/fireworks/models/some-future-model",
     );
-    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "max" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("high");
@@ -1865,7 +1887,8 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
       "fw-key",
       "accounts/fireworks/models/deepseek-v4-pro",
     );
-    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "medium" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("medium");
@@ -1876,7 +1899,8 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
       "fw-key",
       "accounts/fireworks/models/kimi-k2p6",
     );
-    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: { effort: "none" },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("none");
@@ -1887,7 +1911,8 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
       "fw-key",
       "accounts/fireworks/models/kimi-k2p6",
     );
-    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
       config: {
         effort: "max",
         model: "accounts/fireworks/models/deepseek-v4-pro",