fix(provider): make v4 thinking and stream absent-only

Author: TheGreatAxios

src/provider/openai-compatible-adapter.test.ts

@@ -257,6 +257,44 @@ describe("openai-compatible adapter V4 effort wiring", () => {
         some: "existing",
       });
     });
+
+    test("provider-set thinking is preserved (absent-only thinking)", () => {
+      // A provider-supplied thinking value beats the V4 effort's implied one:
+      // `none` normally forces thinking off, but an explicit thinking:true
+      // must be kept (never force-stamped), and vice versa.
+      const noneThenTrue = bodyForModel("deepseek-v4-pro", {
+        providerOptions: {
+          reasoning_effort: "none",
+          chat_template_kwargs: { thinking: true },
+        },
+      } as InferenceOptions);
+      expect(noneThenTrue["chat_template_kwargs"]).toEqual({ thinking: true });
+
+      const xhighThenFalse = bodyForModel("deepseek-v4-pro", {
+        providerOptions: {
+          reasoning_effort: "xhigh",
+          chat_template_kwargs: { thinking: false },
+        },
+      } as InferenceOptions);
+      expect(xhighThenFalse["chat_template_kwargs"]).toEqual({
+        thinking: false,
+      });
+    });
+
+    test("unset effort does not inject empty chat_template_kwargs", () => {
+      const body = bodyForModel("deepseek-v4-pro", {} as InferenceOptions);
+      expect("chat_template_kwargs" in body).toBe(false);
+      expect(body["reasoning_effort"]).toBeUndefined();
+    });
+
+    test("provider-set stream_options is preserved (absent-only)", () => {
+      const body = bodyForModel("deepseek-v4-pro", {
+        providerOptions: {
+          stream_options: { include_usage: false },
+        },
+      } as InferenceOptions);
+      expect(body["stream_options"]).toEqual({ include_usage: false });
+    });
   });
 
   describe("v4-effort is no-op for non-V4", () => {

src/provider/openai-compatible-adapter.ts

@@ -63,17 +63,16 @@ export function createOpenAICompatibleAdapter(
 
     // Merge a thinking toggle into a clone of the existing chat_template_kwargs
     // (never overwrite the object wholesale, and never mutate the caller's
-    // providerOptions ref). For a wire effort the toggle is absent-only: an
-    // explicit provider-set thinking value wins.
+    // providerOptions ref). The toggle is absent-only: a provider-supplied
+    // thinking value wins over the V4 effort's implied value.
     const applyV4Thinking = (thinking: boolean): void => {
       const existing =
         body["chat_template_kwargs"] !== null &&
         typeof body["chat_template_kwargs"] === "object"
           ? (body["chat_template_kwargs"] as Record<string, unknown>)
           : {};
       const merged = { ...existing };
-      if (thinking) merged.thinking ??= true;
-      else merged.thinking = false;
+      merged.thinking ??= thinking;
       Object.assign(body, { chat_template_kwargs: merged });
     };
     // V4 drives its own effort ladder (none/xhigh/max) and encodes thinking via
@@ -100,8 +99,9 @@ export function createOpenAICompatibleAdapter(
         body["top_p"] = DEEPSEEK_V4_MODEL_CARD.topP;
       if (body["temperature"] === undefined)
         body["temperature"] = DEEPSEEK_V4_MODEL_CARD.temperature;
-      if (body["stream_options"] === undefined)
-        body["stream_options"] = V4_STREAM_OPTIONS.stream_options;
+      // Absent-only, mirroring the sampling guard: provider-set stream_options
+      // is never overwritten.
+      body["stream_options"] ??= V4_STREAM_OPTIONS.stream_options;
     }
     if (stripReasoning && Array.isArray(body["messages"])) {
       for (const msg of body["messages"]) {