@vellumai/assistant 0.8.2 → 0.8.4

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

@@ -21,6 +21,13 @@ interface FakeChunk {
   choices: Array<{
     delta: {
       content?: string | null;
+      reasoning_content?: string | null;
+      reasoning?: string | null;
+      reasoning_details?: Array<{
+        type?: string;
+        summary?: string | null;
+        text?: string | null;
+      }> | null;
       tool_calls?: Array<{
         index: number;
         id?: string;
@@ -209,6 +216,44 @@ function cachedUsageChunk(
   };
 }
 
+function reasoningChunk(
+  reasoning: string,
+  finish: string | null = null,
+): FakeChunk {
+  return {
+    choices: [
+      { delta: { reasoning_content: reasoning }, finish_reason: finish },
+    ],
+    usage: null,
+    model: "gpt-5.2",
+  };
+}
+
+// OpenRouter spec uses `delta.reasoning` rather than `delta.reasoning_content`.
+function openRouterReasoningChunk(
+  reasoning: string,
+  finish: string | null = null,
+): FakeChunk {
+  return {
+    choices: [{ delta: { reasoning }, finish_reason: finish }],
+    usage: null,
+    model: "gpt-5.2",
+  };
+}
+
+// OpenRouter's documented reasoning-summary shape: a `reasoning_details` array
+// with entries tagged `reasoning.summary` / `reasoning.text` / `reasoning.encrypted`.
+function reasoningDetailsChunk(
+  details: Array<{ type?: string; summary?: string; text?: string }>,
+  finish: string | null = null,
+): FakeChunk {
+  return {
+    choices: [{ delta: { reasoning_details: details }, finish_reason: finish }],
+    usage: null,
+    model: "gpt-5.2",
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Class extraction sanity checks
 // ---------------------------------------------------------------------------
@@ -339,6 +384,153 @@ describe("OpenAIProvider", () => {
     expect(events[1]).toEqual({ type: "text_delta", text: ", world!" });
   });
 
+  // -----------------------------------------------------------------------
+  // Reasoning content (MiniMax / DeepSeek extension)
+  // -----------------------------------------------------------------------
+  test("parses reasoning_content into thinking block", async () => {
+    fakeChunks = [
+      reasoningChunk("Let me think..."),
+      textChunk("The answer is 42."),
+      usageChunk(10, 20),
+    ];
+
+    const result = await provider.sendMessage([userMsg("Hi")]);
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0]).toEqual({
+      type: "thinking",
+      thinking: "Let me think...",
+      signature: "",
+    });
+    expect(result.content[1]).toEqual({
+      type: "text",
+      text: "The answer is 42.",
+    });
+    expect(result.usage).toEqual({ inputTokens: 10, outputTokens: 20 });
+  });
+
+  test("fires thinking_delta events during streaming", async () => {
+    fakeChunks = [
+      reasoningChunk("Let me think..."),
+      textChunk("The answer is 42."),
+      usageChunk(10, 20),
+    ];
+
+    const events: ProviderEvent[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (e) => events.push(e),
+    });
+
+    expect(events).toHaveLength(2);
+    expect(events[0]).toEqual({
+      type: "thinking_delta",
+      thinking: "Let me think...",
+    });
+    expect(events[1]).toEqual({
+      type: "text_delta",
+      text: "The answer is 42.",
+    });
+  });
+
+  test("reasoning + tool calls orders correctly (thinking → tool_use)", async () => {
+    fakeChunks = [
+      reasoningChunk("Planning..."),
+      ...toolCallChunks([
+        { id: "call_1", name: "file_read", args: '{"path":"/a"}' },
+      ]),
+      usageChunk(10, 30),
+    ];
+
+    const result = await provider.sendMessage([userMsg("Read /a")]);
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0].type).toBe("thinking");
+    expect(result.content[1].type).toBe("tool_use");
+  });
+
+  test("no thinking block when reasoning_content is absent", async () => {
+    fakeChunks = [textChunk("Just text"), usageChunk(10, 5)];
+
+    const result = await provider.sendMessage([userMsg("Hi")]);
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe("text");
+  });
+
+  test("parses OpenRouter's `delta.reasoning` field into thinking block", async () => {
+    fakeChunks = [
+      openRouterReasoningChunk("Hmm, let me think..."),
+      textChunk("Final answer."),
+      usageChunk(10, 8),
+    ];
+
+    const events: ProviderEvent[] = [];
+    const result = await provider.sendMessage(
+      [userMsg("Hi")],
+      undefined,
+      undefined,
+      {
+        onEvent: (e) => events.push(e),
+      },
+    );
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0]).toEqual({
+      type: "thinking",
+      thinking: "Hmm, let me think...",
+      signature: "",
+    });
+    expect(result.content[1]).toEqual({ type: "text", text: "Final answer." });
+    expect(events).toContainEqual({
+      type: "thinking_delta",
+      thinking: "Hmm, let me think...",
+    });
+  });
+
+  test("parses OpenRouter `delta.reasoning_details` summary/text entries and skips encrypted", async () => {
+    fakeChunks = [
+      reasoningDetailsChunk([
+        { type: "reasoning.summary", summary: "Plan step one. " },
+        { type: "reasoning.encrypted", text: "ENCRYPTED_BLOB" },
+        { type: "reasoning.text", text: "Detailed thought." },
+      ]),
+      textChunk("Done."),
+      usageChunk(10, 8),
+    ];
+
+    const events: ProviderEvent[] = [];
+    const result = await provider.sendMessage(
+      [userMsg("Hi")],
+      undefined,
+      undefined,
+      {
+        onEvent: (e) => events.push(e),
+      },
+    );
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0]).toEqual({
+      type: "thinking",
+      thinking: "Plan step one. Detailed thought.",
+      signature: "",
+    });
+    expect(result.content[1]).toEqual({ type: "text", text: "Done." });
+    expect(events).toContainEqual({
+      type: "thinking_delta",
+      thinking: "Plan step one. ",
+    });
+    expect(events).toContainEqual({
+      type: "thinking_delta",
+      thinking: "Detailed thought.",
+    });
+    // Encrypted blob must never surface as visible thinking.
+    for (const e of events) {
+      if (e.type === "thinking_delta") {
+        expect(e.thinking).not.toContain("ENCRYPTED_BLOB");
+      }
+    }
+  });
+
   // -----------------------------------------------------------------------
   // System prompt
   // -----------------------------------------------------------------------
@@ -1306,14 +1498,17 @@ describe("OpenRouterProvider reasoning", () => {
     shouldThrow = null;
   });
 
-  test("sends reasoning.enabled=true when thinking config is present", async () => {
+  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, {
       config: { thinking: { type: "adaptive" } },
     });
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: true });
+    expect(lastCreateParams!.reasoning).toEqual({
+      enabled: true,
+      summary: "detailed",
+    });
   });
 
   test("sends reasoning.enabled=false when thinking is explicitly disabled", async () => {
@@ -1376,7 +1571,10 @@ describe("OpenRouterProvider reasoning", () => {
     await retry.sendMessage([userMsg("hi")], undefined, undefined, {
       config: { thinking: { type: "adaptive" } },
     });
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: true });
+    expect(lastCreateParams!.reasoning).toEqual({
+      enabled: true,
+      summary: "detailed",
+    });
   });
 
   test("RetryProvider + OpenRouterProvider disables thinking end-to-end", async () => {
@@ -1389,6 +1587,23 @@ describe("OpenRouterProvider reasoning", () => {
     });
     expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
   });
+
+  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, {
+      config: { thinking: { enabled: true }, effort: "max" },
+    });
+
+    expect(lastCreateParams).toBeTruthy();
+    expect(lastCreateParams!.reasoning).toEqual({
+      enabled: true,
+      effort: "xhigh",
+      summary: "detailed",
+    });
+    // Critical: must NOT also send the OpenAI-native flat field — OpenRouter
+    // rejects requests that carry both forms for reasoning models.
+    expect(lastCreateParams).not.toHaveProperty("reasoning_effort");
+  });
 });
 
 describe("OpenRouterProvider Anthropic-compatible errors", () => {
@@ -1529,4 +1744,109 @@ describe("OpenAIProvider reasoning_effort", () => {
     });
     expect(lastCreateParams!.reasoning_effort).toBe("medium");
   });
+
+  test('maxReasoningEffort: "max" passes "max" through unclamped', async () => {
+    const uncapped = new OpenAIProvider("test-key", "gpt-5", {
+      maxReasoningEffort: "max",
+    });
+    await uncapped.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+    await uncapped.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
+  });
+});
+
+describe("FireworksProvider reasoning_effort ceiling", () => {
+  beforeEach(() => {
+    fakeChunks = [];
+    lastCreateParams = null;
+  });
+
+  test('DeepSeek V4 Pro accepts "max" unclamped', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+  });
+
+  test('DeepSeek V4 Pro accepts "xhigh" unclamped', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
+  });
+
+  test('Kimi K2.6 clamps "xhigh"/"max" down to "high"', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+  });
+
+  test('unknown Fireworks model falls back to "high" ceiling', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/some-future-model",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+  });
+
+  test("effort below ceiling is forwarded verbatim", async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "medium" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("medium");
+  });
+
+  test('effort: "none" passes through regardless of ceiling', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "none" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("none");
+  });
+
+  test("model override picks ceiling from runtime model, not constructor model", async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: {
+        effort: "max",
+        model: "accounts/fireworks/models/deepseek-v4-pro",
+      },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+  });
 });

package/src/__tests__/openai-responses-cutover-guard.test.ts

@@ -92,9 +92,9 @@ describe("OpenAI Responses API cutover guard", () => {
 
     // The factory must NOT instantiate OpenAIChatCompletionsProvider or
     // OpenAIProvider (the backward-compatible alias) inside the `openai:`
-    // factory entry. Other entries (e.g. `zai:`, `deepseek:`, `minimax:`)
-    // may legitimately use OpenAIChatCompletionsProvider since that's the
-    // OpenAI Chat Completions transport for third-party endpoints.
+    // factory entry. Other entries (e.g. `openai-compatible:`) may legitimately
+    // use OpenAIChatCompletionsProvider since that's the OpenAI Chat Completions
+    // transport for third-party endpoints.
     const openaiEntryRegion =
       /(?:^|\s)openai\s*:\s*\([^)]*\)\s*=>\s*[\s\S]{0,400}?(?=\}\s*,\s*[a-z-]+\s*:|\}\s*;)/m.exec(
         source,

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

@@ -714,16 +714,16 @@ describe("OpenAIResponsesProvider", () => {
   });
 
   // -----------------------------------------------------------------------
-  // store: false
+  // store — omitted so prompt caching can persist across turns
   // -----------------------------------------------------------------------
-  test("sends store: false in params", async () => {
+  test("does not set store in params (defaults to true server-side)", async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage([
       { role: "user", content: [{ type: "text", text: "Hi" }] },
     ]);
 
-    expect(lastStreamParams!.store).toBe(false);
+    expect(lastStreamParams!.store).toBeUndefined();
   });
 
   // -----------------------------------------------------------------------
@@ -1122,7 +1122,7 @@ describe("OpenAIResponsesProvider", () => {
     const rawReq = result.rawRequest as Record<string, unknown>;
     expect(rawReq.model).toBe("gpt-5.2");
     expect(rawReq.instructions).toBe("System prompt");
-    expect(rawReq.store).toBe(false);
+    expect(rawReq.store).toBeUndefined();
 
     // rawResponse should contain the final response object, including `output`
     // which downstream normalization relies on for Responses API detection.

package/src/__tests__/openrouter-provider-only.test.ts

@@ -116,7 +116,7 @@ describe("OpenRouter provider.only plumbing", () => {
       expect(extras.provider).toBe(undefined);
     });
 
-    test("still carries reasoning flag alongside provider.only", () => {
+    test("enables thinking with default detailed summary alongside provider.only", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",
         "x-ai/grok-4.20-beta",
@@ -128,12 +128,12 @@ describe("OpenRouter provider.only plumbing", () => {
         },
       });
       expect(extras).toEqual({
-        reasoning: { enabled: true },
+        reasoning: { enabled: true, summary: "detailed" },
         provider: { only: ["xAI"] },
       });
     });
 
-    test("disabled thinking keeps reasoning disabled alongside provider.only", () => {
+    test("disabled thinking keeps reasoning disabled and omits summary", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",
         "x-ai/grok-4.20-beta",
@@ -149,5 +149,53 @@ describe("OpenRouter provider.only plumbing", () => {
         provider: { only: ["xAI"] },
       });
     });
+
+    test("nests effort under reasoning and maps `max` to xhigh", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          effort: "max",
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, effort: "xhigh", summary: "detailed" },
+      });
+    });
+
+    test("honors a per-call summary override", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          openrouter: { reasoning: { summary: "concise" } },
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, summary: "concise" },
+      });
+    });
+
+    test("ignores an invalid summary override and falls back to detailed", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          openrouter: { reasoning: { summary: "verbose" } },
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, summary: "detailed" },
+      });
+    });
   });
 });

package/src/__tests__/openrouter-token-estimation.test.ts

@@ -5,7 +5,11 @@ import { OpenRouterProvider } from "../providers/openrouter/client.js";
 import type { Message } from "../providers/types.js";
 
 /** Build a minimal valid PNG header encoding the given dimensions. */
-function makePngBase64(width: number, height: number, paddingBytes = 0): string {
+function makePngBase64(
+  width: number,
+  height: number,
+  paddingBytes = 0,
+): string {
   const header = Buffer.alloc(24);
   header[0] = 0x89;
   header[1] = 0x50;
@@ -41,13 +45,13 @@ describe("OpenRouterProvider token estimation routing", () => {
     expect(provider.tokenEstimationProvider).toBe("openrouter");
   });
 
-  test("estimatePromptTokens applies Anthropic image scaling when routed via OpenRouter", () => {
+  test("estimatePromptTokens applies dimension-based image scaling when routed via OpenRouter to Anthropic", () => {
     const provider = new OpenRouterProvider(
       "fake-key",
       "anthropic/claude-opus-4-6",
     );
     // 1920x1080 screenshot with ~200 KB of pixel data → base64/4 would be ~65k
-    // tokens; dimension-based Anthropic rules land around 1.6k tokens.
+    // tokens; dimension-based rules land around 1.6k tokens.
     const messages: Message[] = [
       {
         role: "user",
@@ -68,33 +72,38 @@ describe("OpenRouterProvider token estimation routing", () => {
       providerName: provider.tokenEstimationProvider,
     });
 
-    // Dimension-based estimate should be well under 5k; base64/4 would exceed 50k.
     expect(estimated).toBeLessThan(5_000);
   });
 
-  test("estimatePromptTokens falls back to base64/4 for non-Anthropic OpenRouter models", () => {
-    const provider = new OpenRouterProvider("fake-key", "x-ai/grok-4.20-beta");
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "image",
-            source: {
-              type: "base64",
-              media_type: "image/png",
-              data: makePngBase64(1920, 1080, 200_000),
+  test("estimatePromptTokens applies dimension-based image scaling for non-Anthropic OpenRouter models", () => {
+    // A naive base64/4 estimate on a 1920x1080 screenshot (~200 KB) lands near
+    // 65k tokens and trips spurious compaction long before the real context
+    // window fills. Vision models on OpenRouter — both anthropic/* and
+    // non-Anthropic (Kimi K2.6, Grok, etc.) — must use the dimension-based
+    // formula.
+    for (const model of ["moonshotai/kimi-k2.6", "x-ai/grok-4.20-beta"]) {
+      const provider = new OpenRouterProvider("fake-key", model);
+      const messages: Message[] = [
+        {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: "image/png",
+                data: makePngBase64(1920, 1080, 200_000),
+              },
             },
-          },
-        ],
-      },
-    ];
+          ],
+        },
+      ];
 
-    const estimated = estimatePromptTokens(messages, "system", {
-      providerName: provider.tokenEstimationProvider,
-    });
+      const estimated = estimatePromptTokens(messages, "system", {
+        providerName: provider.tokenEstimationProvider,
+      });
 
-    // Base64/4 heuristic on ~200 KB of image data → far more than 10k tokens.
-    expect(estimated).toBeGreaterThan(50_000);
+      expect(estimated).toBeLessThan(5_000);
+    }
   });
 });