@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/providers/openai/__tests__/chat-completions-provider-reasoning.test.ts

@@ -934,55 +934,6 @@ describe("thinking-mode tool_choice rejection fallback", () => {
     expect(text?.text).toBe("ok");
   });
 
-  test("retries once when Kimi rejects a specified tool_choice in thinking mode", async () => {
-    const { provider, requests } = stubProviderWithErrors(
-      [
-        rejection(
-          "tool_choice 'specified' is incompatible with thinking enabled",
-        ),
-      ],
-      OK_CHUNKS,
-    );
-
-    const response = await provider.sendMessage(
-      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
-      {
-        tools: [
-          {
-            name: "select_pages",
-            description: "Pick relevant memory pages",
-            input_schema: { type: "object", properties: {} },
-          },
-        ],
-        config: {
-          tool_choice: { type: "tool", name: "select_pages" },
-          effort: "high",
-        },
-      },
-    );
-
-    expect(requests).toHaveLength(2);
-    const first = requests[0] as {
-      tool_choice?: { type: string; function: { name: string } };
-      reasoning_effort?: string;
-    };
-    const second = requests[1] as {
-      tool_choice?: unknown;
-      reasoning_effort?: string;
-    };
-    expect(first.tool_choice).toEqual({
-      type: "function",
-      function: { name: "select_pages" },
-    });
-    expect(first.reasoning_effort).toBe("high");
-    expect(second.tool_choice).toBeUndefined();
-    expect(second.reasoning_effort).toBe("high");
-    const text = response.content.find((b) => b.type === "text") as
-      | { type: "text"; text: string }
-      | undefined;
-    expect(text?.text).toBe("ok");
-  });
-
   test("retries once for an OpenRouter-wrapped thinking-mode tool_choice rejection", async () => {
     const wrapped = new OpenAI.APIError(
       400,
@@ -1190,80 +1141,33 @@ describe("unknown assistant reasoning field rejection fallback", () => {
     },
   ];
 
-  test.each([
-    [
-      "a strict schema",
-      "Additional properties are not allowed ('reasoning_content' was unexpected)",
-    ],
-    ["Groq", "property 'reasoning_content' is unsupported"],
-  ])(
-    "retries once without reasoning_content when %s rejects it",
-    async (_upstream, message) => {
-      const { provider, requests } = stubProviderWithErrors(
-        [rejection(message)],
-        OK_CHUNKS,
-        { assistantReasoningField: "reasoning_content" },
-      );
-
-      const response = await provider.sendMessage(thinkingHistory);
-
-      expect(requests).toHaveLength(2);
-      const first = requests[0] as {
-        messages: Array<{ reasoning_content?: string; content: string | null }>;
-      };
-      const second = requests[1] as {
-        messages: Array<{ reasoning_content?: string; content: string | null }>;
-      };
-      expect(first.messages[0].reasoning_content).toBe("hidden chain");
-      expect(second.messages[0].reasoning_content).toBeUndefined();
-      expect(second.messages[0].content).toBe("answer");
-      const text = response.content.find((b) => b.type === "text") as
-        | { type: "text"; text: string }
-        | undefined;
-      expect(text?.text).toBe("ok");
-    },
-  );
-
-  test("preserves assistant tool calls when stripping an unsupported reasoning_content", async () => {
+  test("retries once without reasoning_content when a strict schema rejects it", async () => {
     const { provider, requests } = stubProviderWithErrors(
-      [rejection("property 'reasoning_content' is unsupported")],
+      [
+        rejection(
+          "Additional properties are not allowed ('reasoning_content' was unexpected)",
+        ),
+      ],
       OK_CHUNKS,
       { assistantReasoningField: "reasoning_content" },
     );
 
-    await provider.sendMessage([
-      {
-        role: "assistant",
-        content: [
-          { type: "thinking", thinking: "hidden chain", signature: "" },
-          {
-            type: "tool_use",
-            id: "call_1",
-            name: "lookup",
-            input: { q: "x" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "call_1", content: "found" },
-        ],
-      },
-    ]);
+    const response = await provider.sendMessage(thinkingHistory);
 
     expect(requests).toHaveLength(2);
+    const first = requests[0] as {
+      messages: Array<{ reasoning_content?: string; content: string | null }>;
+    };
     const second = requests[1] as {
-      messages: Array<{
-        role: string;
-        reasoning_content?: string;
-        tool_calls?: Array<{ id: string; function: { name: string } }>;
-      }>;
+      messages: Array<{ reasoning_content?: string; content: string | null }>;
     };
-    const assistant = second.messages.find((m) => m.role === "assistant");
-    expect(assistant?.reasoning_content).toBeUndefined();
-    expect(assistant?.tool_calls?.[0]?.id).toBe("call_1");
-    expect(assistant?.tool_calls?.[0]?.function.name).toBe("lookup");
+    expect(first.messages[0].reasoning_content).toBe("hidden chain");
+    expect(second.messages[0].reasoning_content).toBeUndefined();
+    expect(second.messages[0].content).toBe("answer");
+    const text = response.content.find((b) => b.type === "text") as
+      | { type: "text"; text: string }
+      | undefined;
+    expect(text?.text).toBe("ok");
   });
 
   test("does not strip reasoning_content on a must-be-passed-back error", async () => {
@@ -1285,38 +1189,6 @@ describe("unknown assistant reasoning field rejection fallback", () => {
     ).toBe("hidden chain");
   });
 
-  test("does not strip reasoning_content on a 429 output-token limit", async () => {
-    const { provider, requests } = stubProviderWithErrors(
-      [
-        rejection(
-          "Rate limit reached for model `qwen/qwen3-32b` in organization `org_x` on tokens per minute (TPM): Limit 1000, Requested 4000.",
-          429,
-        ),
-      ],
-      OK_CHUNKS,
-      { assistantReasoningField: "reasoning_content" },
-    );
-
-    await expect(provider.sendMessage(thinkingHistory)).rejects.toThrow();
-    expect(requests).toHaveLength(1);
-  });
-
-  test("does not strip reasoning_content on a 413 input-token limit", async () => {
-    const { provider, requests } = stubProviderWithErrors(
-      [
-        rejection(
-          "Request too large for model `qwen/qwen3-32b` in organization `org_x` on tokens per minute (TPM): Limit 7000, Requested 24936.",
-          413,
-        ),
-      ],
-      OK_CHUNKS,
-      { assistantReasoningField: "reasoning_content" },
-    );
-
-    await expect(provider.sendMessage(thinkingHistory)).rejects.toThrow();
-    expect(requests).toHaveLength(1);
-  });
-
   test("does not retry unknown-field 500s", async () => {
     const { provider, requests } = stubProviderWithErrors(
       [

package/src/providers/openai/__tests__/tool-choice-mapping.test.ts

@@ -26,14 +26,13 @@ const USER_MESSAGE: Message[] = [
  */
 function stubChatProvider(
   options?: ConstructorParameters<typeof OpenAIChatCompletionsProvider>[2],
-  model = "test-model",
 ): {
   provider: OpenAIChatCompletionsProvider;
   requests: Array<Record<string, unknown>>;
 } {
   const provider = new OpenAIChatCompletionsProvider(
     "test-key",
-    model,
+    "test-model",
     options,
   );
   const requests: Array<Record<string, unknown>> = [];
@@ -236,87 +235,6 @@ describe("OpenAIChatCompletionsProvider tool_choice wiring", () => {
     });
   });
 
-  test("omits a forced tool choice for OpenRouter Kimi K2.6 with thinking", async () => {
-    const { provider, requests } = stubChatProvider(
-      { providerName: "openrouter" },
-      "moonshotai/kimi-k2.6-20260420",
-    );
-
-    await provider.sendMessage(USER_MESSAGE, {
-      tools: TOOLS,
-      config: { tool_choice: { type: "tool", name: "bash" }, effort: "high" },
-    });
-
-    expect(requests).toHaveLength(1);
-    expect(requests[0].reasoning_effort).toBe("high");
-    expect(requests[0].tool_choice).toBeUndefined();
-  });
-
-  test("omits required for OpenRouter Kimi K2.6 with thinking", async () => {
-    const { provider, requests } = stubChatProvider(
-      { providerName: "openrouter" },
-      "moonshotai/kimi-k2.6-20260420",
-    );
-
-    await provider.sendMessage(USER_MESSAGE, {
-      tools: TOOLS,
-      config: { tool_choice: { type: "any" }, effort: "high" },
-    });
-
-    expect(requests).toHaveLength(1);
-    expect(requests[0].reasoning_effort).toBe("high");
-    expect(requests[0].tool_choice).toBeUndefined();
-  });
-
-  test("keeps tool_choice none for OpenRouter Kimi K2.6 with thinking", async () => {
-    const { provider, requests } = stubChatProvider(
-      { providerName: "openrouter" },
-      "moonshotai/kimi-k2.6-20260420",
-    );
-
-    await provider.sendMessage(USER_MESSAGE, {
-      tools: TOOLS,
-      config: { tool_choice: { type: "none" }, effort: "high" },
-    });
-
-    expect(requests[0].reasoning_effort).toBe("high");
-    expect(requests[0].tool_choice).toBe("none");
-  });
-
-  test("keeps a forced tool choice for OpenRouter Kimi K2.6 when thinking is off", async () => {
-    const { provider, requests } = stubChatProvider(
-      { providerName: "openrouter" },
-      "moonshotai/kimi-k2.6-20260420",
-    );
-
-    await provider.sendMessage(USER_MESSAGE, {
-      tools: TOOLS,
-      config: { tool_choice: { type: "tool", name: "bash" } },
-    });
-
-    expect(requests[0].tool_choice).toEqual({
-      type: "function",
-      function: { name: "bash" },
-    });
-  });
-
-  test("keeps a forced tool choice for Vercel Kimi K2.6 with thinking", async () => {
-    const { provider, requests } = stubChatProvider(
-      { providerName: "vercel-ai-gateway" },
-      "moonshotai/kimi-k2.6",
-    );
-
-    await provider.sendMessage(USER_MESSAGE, {
-      tools: TOOLS,
-      config: { tool_choice: { type: "tool", name: "bash" }, effort: "high" },
-    });
-
-    expect(requests[0].tool_choice).toEqual({
-      type: "function",
-      function: { name: "bash" },
-    });
-  });
-
   test("omits every tool_choice in thinking mode when omitToolChoiceWhenReasoning is on", async () => {
     const { provider, requests } = stubChatProvider({
       omitToolChoiceWhenReasoning: true,