@vellumai/assistant 0.11.4 → 0.11.5-staging.2

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

@@ -294,6 +294,53 @@ describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
     });
   });
 
+  test("round-trips reasoning_content on assistant messages that carry tool_calls", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
+        },
+      ],
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await provider.sendMessage([
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "thinking",
+            thinking: "need the search tool",
+            signature: "",
+          },
+          { type: "tool_use", id: "call_1", name: "search", input: { q: "x" } },
+        ],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        content: string | null;
+        reasoning_content?: string;
+        tool_calls?: unknown;
+      }>;
+    };
+    expect(params.messages[0]).toEqual({
+      role: "assistant",
+      content: null,
+      reasoning_content: "need the search tool",
+      tool_calls: [
+        {
+          id: "call_1",
+          type: "function",
+          function: { name: "search", arguments: JSON.stringify({ q: "x" }) },
+        },
+      ],
+    });
+  });
+
   test("uses reasoning field for OpenRouter-style round-trip", async () => {
     const { provider, requests } = stubProvider(
       [
@@ -438,18 +485,88 @@ describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
     };
     const assistantMsg = params.messages.find((m) => m.role === "assistant")!;
     // Backfill defaults off, so providers that tolerate null assistant content
-    // (e.g. OpenAI proper) are unaffected by the OpenRouter-specific guard.
+    // (e.g. Fireworks, Together) are unaffected unless they opt in.
     expect(assistantMsg.content).toBeNull();
   });
 
-  test("does not backfill content when tool calls are present", async () => {
-    const { provider, requests } = stubProvider([
+  test("backfills placeholder when thinking is dropped and no text was emitted", async () => {
+    // Custom openai-compatible endpoints do not set assistantReasoningField, so
+    // a Stop during thinking serializes to { role: "assistant", content: null }
+    // unless the backfill guard runs.
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
+        },
+      ],
+      { backfillEmptyAssistantContent: true },
+    );
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "question" }] },
       {
-        choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
-        usage: { prompt_tokens: 2, completion_tokens: 1 },
+        role: "assistant",
+        content: [
+          {
+            type: "thinking",
+            thinking: "aborted mid-thought",
+            signature: "",
+          },
+        ],
       },
     ]);
 
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        content: string | null;
+        reasoning?: string;
+        reasoning_content?: string;
+        tool_calls?: unknown;
+      }>;
+    };
+    const assistantMsg = params.messages.find((m) => m.role === "assistant")!;
+    expect(assistantMsg.content).toBe(EMPTY_ASSISTANT_TURN_PLACEHOLDER);
+    expect(assistantMsg.tool_calls).toBeUndefined();
+    expect(assistantMsg.reasoning).toBeUndefined();
+    expect(assistantMsg.reasoning_content).toBeUndefined();
+  });
+
+  test("backfills placeholder for an empty aborted assistant turn", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
+        },
+      ],
+      { backfillEmptyAssistantContent: true },
+    );
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "question" }] },
+      { role: "assistant", content: [] },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{ role: string; content: string | null }>;
+    };
+    const assistantMsg = params.messages.find((m) => m.role === "assistant")!;
+    expect(assistantMsg.content).toBe(EMPTY_ASSISTANT_TURN_PLACEHOLDER);
+  });
+
+  test("does not backfill content when tool calls are present", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
+        },
+      ],
+      { backfillEmptyAssistantContent: true },
+    );
+
     await provider.sendMessage([
       {
         role: "assistant",
@@ -460,12 +577,18 @@ describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
     ]);
 
     const params = requests[0] as {
-      messages: Array<{ role: string; content: string | null }>;
+      messages: Array<{
+        role: string;
+        content: string | null;
+        reasoning_content?: string;
+      }>;
     };
     // Tool-call-only assistant messages keep null content (preferred by
     // Anthropic-proxy/Bedrock backends); the placeholder is only for the
-    // neither-content-nor-tool_calls case.
+    // neither-content-nor-tool_calls case. The reasoning field stays omitted
+    // when assistantReasoningField is unset.
     expect(params.messages[0].content).toBeNull();
+    expect(params.messages[0].reasoning_content).toBeUndefined();
   });
 
   test("forwards config.top_p onto the request body", async () => {
@@ -535,52 +658,153 @@ describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
     };
     expect(params.messages[0].reasoning_content).toBe("deepseek thinking");
   });
-});
 
-describe("reasoning opt-out rejection fallback", () => {
-  function stubProviderWithErrors(
-    errors: unknown[],
-    chunks: MockChunk[],
-  ): { provider: OpenAIChatCompletionsProvider; requests: unknown[] } {
-    const provider = new OpenAIChatCompletionsProvider(
-      "test-key",
-      "test-model",
-    );
-    const requests: unknown[] = [];
-    const pending = [...errors];
-    (provider as unknown as { client: unknown }).client = {
-      chat: {
-        completions: {
-          create: async (params: unknown) => {
-            // Snapshot: the fallback mutates `params` between attempts.
-            requests.push(JSON.parse(JSON.stringify(params)));
-            const error = pending.shift();
-            if (error !== undefined) {
-              throw error;
-            }
-            return makeStream(chunks);
-          },
+  test("omits empty reasoning_content on tool-call turns even when the field is set", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
         },
+      ],
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await provider.sendMessage([
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "call_1", name: "search", input: { q: "x" } },
+        ],
       },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        content: string | null;
+        tool_calls?: unknown;
+        reasoning_content?: string;
+      }>;
     };
-    return { provider, requests };
-  }
+    const assistantMsg = params.messages[0];
+    expect(assistantMsg.tool_calls).toEqual([
+      {
+        id: "call_1",
+        type: "function",
+        function: { name: "search", arguments: JSON.stringify({ q: "x" }) },
+      },
+    ]);
+    expect(assistantMsg.reasoning_content).toBeUndefined();
+  });
 
-  const okChunks: MockChunk[] = [
-    {
-      choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
-      usage: { prompt_tokens: 1, completion_tokens: 1 },
+  test("omits empty reasoning on tool-call turns for the OpenRouter-style field", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
+        },
+      ],
+      { assistantReasoningField: "reasoning" },
+    );
+
+    await provider.sendMessage([
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "call_1", name: "search", input: { q: "x" } },
+        ],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        reasoning?: string;
+        reasoning_content?: string;
+      }>;
+    };
+    expect(params.messages[0].reasoning).toBeUndefined();
+    expect(params.messages[0].reasoning_content).toBeUndefined();
+  });
+
+  test("omits empty reasoning_content on text-only turns even when the field is set", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
+        },
+      ],
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await provider.sendMessage([
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "plain reply" }],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        content: string | null;
+        reasoning_content?: string;
+      }>;
+    };
+    expect(params.messages[0].content).toBe("plain reply");
+    expect(params.messages[0].reasoning_content).toBeUndefined();
+  });
+});
+
+function stubProviderWithErrors(
+  errors: unknown[],
+  chunks: MockChunk[],
+  options?: OpenAIChatCompletionsProviderOptions,
+): { provider: OpenAIChatCompletionsProvider; requests: unknown[] } {
+  const provider = new OpenAIChatCompletionsProvider(
+    "test-key",
+    "test-model",
+    options,
+  );
+  const requests: unknown[] = [];
+  const pending = [...errors];
+  (provider as unknown as { client: unknown }).client = {
+    chat: {
+      completions: {
+        create: async (params: unknown) => {
+          // Snapshot: the fallback mutates `params` between attempts.
+          requests.push(JSON.parse(JSON.stringify(params)));
+          const error = pending.shift();
+          if (error !== undefined) {
+            throw error;
+          }
+          return makeStream(chunks);
+        },
+      },
     },
-  ];
+  };
+  return { provider, requests };
+}
+
+const OK_CHUNKS: MockChunk[] = [
+  {
+    choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+    usage: { prompt_tokens: 1, completion_tokens: 1 },
+  },
+];
 
-  function rejection(message: string, status = 400): Error {
-    return Object.assign(new Error(message), { status });
-  }
+function rejection(message: string, status = 400): Error {
+  return Object.assign(new Error(message), { status });
+}
 
+describe("reasoning opt-out rejection fallback", () => {
   test("retries once without reasoning params when a model rejects the explicit opt-out", async () => {
     const { provider, requests } = stubProviderWithErrors(
       [rejection("reasoning_effort 'none' is not supported for this model")],
-      okChunks,
+      OK_CHUNKS,
     );
 
     const response = await provider.sendMessage(
@@ -626,7 +850,7 @@ describe("reasoning opt-out rejection fallback", () => {
     // can only fire off the normalized upstream detail.
     expect(/reasoning/i.test(wrapped.message)).toBe(false);
 
-    const { provider, requests } = stubProviderWithErrors([wrapped], okChunks);
+    const { provider, requests } = stubProviderWithErrors([wrapped], OK_CHUNKS);
 
     const response = await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "hi" }] }],
@@ -651,7 +875,7 @@ describe("reasoning opt-out rejection fallback", () => {
   test("does not retry when the request did not opt out of reasoning", async () => {
     const { provider, requests } = stubProviderWithErrors(
       [rejection("reasoning_effort is invalid")],
-      okChunks,
+      OK_CHUNKS,
     );
 
     await expect(
@@ -666,7 +890,7 @@ describe("reasoning opt-out rejection fallback", () => {
   test("does not retry a 4xx that does not name reasoning", async () => {
     const { provider, requests } = stubProviderWithErrors(
       [rejection("invalid api key")],
-      okChunks,
+      OK_CHUNKS,
     );
 
     await expect(
@@ -681,7 +905,7 @@ describe("reasoning opt-out rejection fallback", () => {
   test("does not retry server errors", async () => {
     const { provider, requests } = stubProviderWithErrors(
       [rejection("reasoning backend unavailable", 500)],
-      okChunks,
+      OK_CHUNKS,
     );
 
     await expect(
@@ -694,6 +918,312 @@ describe("reasoning opt-out rejection fallback", () => {
   });
 });
 
+describe("thinking-mode tool_choice rejection fallback", () => {
+  test("retries once without tool_choice when thinking mode rejects it", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [rejection("Thinking mode does not support this tool_choice")],
+      OK_CHUNKS,
+    );
+
+    const response = await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      {
+        tools: [
+          {
+            name: "bash",
+            description: "Run a shell command",
+            input_schema: { type: "object", properties: {} },
+          },
+        ],
+        config: { tool_choice: { type: "none" }, effort: "high" },
+      },
+    );
+
+    expect(requests).toHaveLength(2);
+    const first = requests[0] as {
+      tool_choice?: string;
+      reasoning_effort?: string;
+    };
+    const second = requests[1] as {
+      tool_choice?: string;
+      reasoning_effort?: string;
+    };
+    expect(first.tool_choice).toBe("none");
+    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,
+      {
+        code: 400,
+        message: "Provider returned error",
+        metadata: {
+          raw: "[invalid_request_error] Thinking mode does not support this tool_choice",
+          provider_name: "deepseek",
+        },
+      },
+      undefined,
+      new Headers(),
+    );
+    expect(/tool_choice/i.test(wrapped.message)).toBe(false);
+
+    const { provider, requests } = stubProviderWithErrors([wrapped], OK_CHUNKS);
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      {
+        tools: [
+          {
+            name: "bash",
+            description: "Run a shell command",
+            input_schema: { type: "object", properties: {} },
+          },
+        ],
+        config: { tool_choice: { type: "none" }, effort: "high" },
+      },
+    );
+
+    expect(requests).toHaveLength(2);
+    expect((requests[0] as { tool_choice?: string }).tool_choice).toBe("none");
+    expect((requests[1] as { tool_choice?: string }).tool_choice).toBeUndefined();
+  });
+
+  test("does not retry a 4xx that does not name tool_choice", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [rejection("invalid api key")],
+      OK_CHUNKS,
+    );
+
+    await expect(
+      provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+        {
+          tools: [
+            {
+              name: "bash",
+              description: "Run a shell command",
+              input_schema: { type: "object", properties: {} },
+            },
+          ],
+          config: { tool_choice: { type: "none" }, effort: "high" },
+        },
+      ),
+    ).rejects.toThrow();
+    expect(requests).toHaveLength(1);
+  });
+
+  test("does not retry thinking-mode tool_choice 500s", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [rejection("Thinking mode does not support this tool_choice", 500)],
+      OK_CHUNKS,
+    );
+
+    await expect(
+      provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+        {
+          tools: [
+            {
+              name: "bash",
+              description: "Run a shell command",
+              input_schema: { type: "object", properties: {} },
+            },
+          ],
+          config: { tool_choice: { type: "none" }, effort: "high" },
+        },
+      ),
+    ).rejects.toThrow();
+    expect(requests).toHaveLength(1);
+  });
+});
+
+describe("missing reasoning_content rejection fallback", () => {
+  const toolCallHistory = [
+    {
+      role: "assistant" as const,
+      content: [
+        {
+          type: "tool_use" as const,
+          id: "call_1",
+          name: "search",
+          input: { q: "x" },
+        },
+      ],
+    },
+  ];
+
+  test("retries once with empty reasoning_content when thinking mode requires it", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [
+        rejection(
+          "The reasoning_content in the thinking mode must be passed back to the API",
+        ),
+      ],
+      OK_CHUNKS,
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    const response = await provider.sendMessage(toolCallHistory);
+
+    expect(requests).toHaveLength(2);
+    const first = requests[0] as {
+      messages: Array<{ reasoning_content?: string }>;
+    };
+    const second = requests[1] as {
+      messages: Array<{ reasoning_content?: string }>;
+    };
+    expect(first.messages[0].reasoning_content).toBeUndefined();
+    expect(second.messages[0].reasoning_content).toBe("");
+    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 missing reasoning_content rejection", async () => {
+    const wrapped = new OpenAI.APIError(
+      400,
+      {
+        code: 400,
+        message: "Provider returned error",
+        metadata: {
+          raw: "[invalid_request_error] The reasoning_content in the thinking mode must be passed back to the API",
+          provider_name: "deepseek",
+        },
+      },
+      undefined,
+      new Headers(),
+    );
+    expect(/reasoning_content/i.test(wrapped.message)).toBe(false);
+
+    const { provider, requests } = stubProviderWithErrors([wrapped], OK_CHUNKS, {
+      assistantReasoningField: "reasoning_content",
+    });
+
+    await provider.sendMessage(toolCallHistory);
+
+    expect(requests).toHaveLength(2);
+    expect(
+      (requests[0] as { messages: Array<{ reasoning_content?: string }> })
+        .messages[0].reasoning_content,
+    ).toBeUndefined();
+    expect(
+      (requests[1] as { messages: Array<{ reasoning_content?: string }> })
+        .messages[0].reasoning_content,
+    ).toBe("");
+  });
+
+  test("does not retry a 4xx that does not require reasoning_content round-trip", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [rejection("invalid api key")],
+      OK_CHUNKS,
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await expect(provider.sendMessage(toolCallHistory)).rejects.toThrow();
+    expect(requests).toHaveLength(1);
+  });
+
+  test("does not retry missing reasoning_content 500s", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [
+        rejection(
+          "The reasoning_content in the thinking mode must be passed back to the API",
+          500,
+        ),
+      ],
+      OK_CHUNKS,
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await expect(provider.sendMessage(toolCallHistory)).rejects.toThrow();
+    expect(requests).toHaveLength(1);
+  });
+});
+
+describe("unknown assistant reasoning field rejection fallback", () => {
+  const thinkingHistory = [
+    {
+      role: "assistant" as const,
+      content: [
+        { type: "thinking" as const, thinking: "hidden chain", signature: "" },
+        { type: "text" as const, text: "answer" },
+      ],
+    },
+  ];
+
+  test("retries once without reasoning_content when a strict schema rejects it", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [
+        rejection(
+          "Additional properties are not allowed ('reasoning_content' was unexpected)",
+        ),
+      ],
+      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("does not strip reasoning_content on a must-be-passed-back error", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [
+        rejection(
+          "The reasoning_content in the thinking mode must be passed back to the API",
+        ),
+      ],
+      OK_CHUNKS,
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await expect(provider.sendMessage(thinkingHistory)).rejects.toThrow();
+    expect(requests).toHaveLength(1);
+    expect(
+      (requests[0] as { messages: Array<{ reasoning_content?: string }> })
+        .messages[0].reasoning_content,
+    ).toBe("hidden chain");
+  });
+
+  test("does not retry unknown-field 500s", async () => {
+    const { provider, requests } = stubProviderWithErrors(
+      [
+        rejection(
+          "Additional properties are not allowed ('reasoning_content' was unexpected)",
+          500,
+        ),
+      ],
+      OK_CHUNKS,
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await expect(provider.sendMessage(thinkingHistory)).rejects.toThrow();
+    expect(requests).toHaveLength(1);
+  });
+});
+
 describe("OpenAIChatCompletionsProvider cache usage parsing", () => {
   test("maps prompt_tokens_details cache fields into usage", async () => {
     // prompt_tokens is the inclusive total; the cached subset surfaces as