@vellumai/assistant 0.12.0-dev.202609110124.4b134bf → 0.12.0-dev.202609110918.dd3fa5e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.0-dev.202609110124.4b134bf",
+  "version": "0.12.0-dev.202609110918.dd3fa5e",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/llm-catalog-parity.test.ts

@@ -6,6 +6,7 @@ import {
   getCatalogProviderForModel,
   isModelInCatalog,
   PROVIDER_CATALOG,
+  supportsForcedToolChoiceWithThinking,
 } from "../providers/model-catalog.js";
 import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
 import { resolvePricing, resolvePricingForUsage } from "../util/pricing.js";
@@ -551,6 +552,30 @@ describe("LLM catalog parity: daemon vs client", () => {
     expect(getCatalogProviderForModel("unknown/model")).toBeUndefined();
   });
 
+  test("forced tool choice with thinking is scoped to OpenRouter Kimi K2.6", () => {
+    expect(
+      supportsForcedToolChoiceWithThinking("openrouter", "moonshotai/kimi-k2.6"),
+    ).toBe(false);
+    expect(
+      supportsForcedToolChoiceWithThinking(
+        "openrouter",
+        "moonshotai/kimi-k2.6-20260420",
+      ),
+    ).toBe(false);
+    expect(
+      supportsForcedToolChoiceWithThinking(
+        "vercel-ai-gateway",
+        "moonshotai/kimi-k2.6",
+      ),
+    ).toBe(true);
+    expect(
+      supportsForcedToolChoiceWithThinking("openrouter", "unknown/model"),
+    ).toBe(true);
+    expect(
+      supportsForcedToolChoiceWithThinking("unknown-provider", "unknown/model"),
+    ).toBe(true);
+  });
+
   test("Gemini 2.5 Pro catalog context matches provider limits", () => {
     const gemini = PROVIDER_CATALOG.find((entry) => entry.id === "gemini");
     expect(

package/src/plugins/defaults/memory/v3/__tests__/pool-select.test.ts

@@ -39,6 +39,7 @@ import type {
   SendMessageOptions,
 } from "@vellumai/plugin-api";
 
+import { OpenRouterProvider } from "../../../../../providers/openrouter/client.js";
 import { ProviderError } from "../../../../../util/errors.js";
 import { sectionHeadLine } from "../sections.js";
 import type { MemoryRoutingTurn, Section } from "../types.js";
@@ -843,3 +844,91 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+// selectPool: cataloged thinking and forced-tool compatibility.
+// ---------------------------------------------------------------------------
+
+describe("selectPool: cataloged thinking and forced-tool compatibility", () => {
+  test("OpenRouter Kimi K2.6 omits the forced choice and yields a structured selection", async () => {
+    // A real OpenAI chat-completions provider stands in for the cataloged
+    // OpenRouter Kimi profile. The request succeeds without a reactive retry
+    // because the forced select_pages choice is omitted before dispatch.
+    const wireRequests: unknown[] = [];
+    const kimi = new OpenRouterProvider(
+      "test-key",
+      "moonshotai/kimi-k2.6-20260420",
+    );
+    (kimi as unknown as { client: unknown }).client = {
+      chat: {
+        completions: {
+          create: async (params: unknown) => {
+            wireRequests.push(JSON.parse(JSON.stringify(params)));
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield {
+                  choices: [
+                    {
+                      delta: {
+                        tool_calls: [
+                          {
+                            index: 0,
+                            id: "call-1",
+                            function: {
+                              name: "select_pages",
+                              arguments: '{"ids":[3]}',
+                            },
+                          },
+                        ],
+                      },
+                      finish_reason: "tool_calls",
+                    },
+                  ],
+                  usage: { prompt_tokens: 10, completion_tokens: 2 },
+                };
+              },
+            };
+          },
+        },
+      },
+    };
+
+    // The profile layer injects the thinking effort onto the call config in
+    // production; emulate that here so the forced tool_choice rides alongside
+    // reasoning on the wire.
+    providerStub = {
+      name: "kimi-openai-compat",
+      sendMessage: (messages: Message[], options?: SendMessageOptions) =>
+        kimi.sendMessage(messages, {
+          ...options,
+          config: {
+            ...options?.config,
+            effort: "high",
+            thinking: { enabled: true },
+          },
+        }),
+    };
+
+    const selection = await selectPool(makePool(), makeTurn("rollout?"));
+
+    // The preflight path avoids an incompatible first request, and the
+    // pool-level re-prompt loop never engages.
+    expect(wireRequests).toHaveLength(1);
+    const first = wireRequests[0] as {
+      tool_choice?: unknown;
+      reasoning?: { effort?: string; summary?: string };
+    };
+    expect(first.tool_choice).toBeUndefined();
+    expect(first.reasoning).toMatchObject({
+      effort: "high",
+      summary: "detailed",
+    });
+    expect(
+      warnPayloads().filter((p) => p.reason === "provider_error"),
+    ).toEqual([]);
+
+    // Structured selection survived: ids [3] is the topic-x finder line.
+    expect(selection.keptAll).toBe(false);
+    expect(selection.pages).toEqual([{ slug: "topic-x", sections: [] }]);
+  });
+});

package/src/providers/model-catalog.ts

@@ -76,6 +76,13 @@ export interface CatalogModel {
   supportsAudioInput?: boolean;
   supportsToolUse?: boolean;
   supportsEffort?: boolean;
+  /**
+   * Whether this provider/model serving surface accepts a forced OpenAI
+   * chat-completions tool choice while thinking is enabled. Omit unless the
+   * combination is known incompatible. Daemon-only: not projected into the
+   * client catalog (see scripts/sync-llm-catalog.ts).
+   */
+  supportsForcedToolChoiceWithThinking?: boolean;
   pricing?: CatalogModelPricing;
   /**
    * Upper bound for `reasoning_effort` accepted by this model's upstream API.
@@ -1816,6 +1823,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsCaching: true,
         supportsVision: true,
         supportsToolUse: true,
+        supportsForcedToolChoiceWithThinking: false,
         pricing: {
           inputPer1mTokens: 0.95,
           outputPer1mTokens: 4.0,
@@ -2628,6 +2636,30 @@ export function modelSupportedEfforts(
   );
 }
 
+/**
+ * Whether a provider/model serving surface accepts a forced OpenAI
+ * chat-completions tool choice while thinking is enabled. Unknown providers
+ * and models fail open so custom routes retain their existing request shape
+ * and can rely on the bounded provider-error retry if needed.
+ */
+export function supportsForcedToolChoiceWithThinking(
+  providerId: string,
+  modelId: string,
+): boolean {
+  const provider = PROVIDER_CATALOG.find((entry) => entry.id === providerId);
+  if (!provider) {
+    return true;
+  }
+  const stripDateSuffix = (id: string): string => id.replace(/-\d{8}$/, "");
+  const normalizedModelId = stripDateSuffix(modelId);
+  return !provider.models.some(
+    (model) =>
+      model.supportsForcedToolChoiceWithThinking === false &&
+      (model.id === modelId ||
+        stripDateSuffix(model.id) === normalizedModelId),
+  );
+}
+
 /**
  * Return the catalog provider that owns a model ID, if known. When multiple
  * providers list the same ID (e.g. OpenRouter and the Vercel AI Gateway share

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

@@ -934,6 +934,51 @@ 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,

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

@@ -26,13 +26,14 @@ 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",
-    "test-model",
+    model,
     options,
   );
   const requests: Array<Record<string, unknown>> = [];
@@ -235,6 +236,87 @@ 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,

package/src/providers/openai/chat-completions-provider.ts

@@ -17,6 +17,7 @@ import {
   mediaSourceByteLength,
   resolveMediaReferences,
 } from "../media-resolve.js";
+import { supportsForcedToolChoiceWithThinking } from "../model-catalog.js";
 import { PLACEHOLDER_EMPTY_TURN } from "../placeholder-sentinels.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
 import { createStreamTimeout } from "../stream-timeout.js";
@@ -404,9 +405,15 @@ export function isThinkingEnabledOnWire(params: unknown): boolean {
  * rejected it because thinking/reasoning mode forbids that parameter.
  * DeepSeek thinking mode 400s with `Thinking mode does not support this
  * tool_choice` for any explicit value, including `"auto"` and `"none"`.
- * One retry without `tool_choice` lets the same provider succeed instead of
- * failing over to a different backend.
+ * Kimi 400s with `tool_choice 'specified' is incompatible with thinking
+ * enabled`. One retry without `tool_choice` lets the same provider succeed
+ * instead of failing over to a different backend.
  */
+const THINKING_MODE_TOOL_CHOICE_REJECTION_PATTERNS: RegExp[] = [
+  /does not support this tool_choice/i,
+  /tool_choice\s+'specified'\s+is incompatible with thinking/i,
+];
+
 function isThinkingModeToolChoiceRejection(
   error: unknown,
   params: unknown,
@@ -418,8 +425,9 @@ function isThinkingModeToolChoiceRejection(
   if (!isClientErrorStatus(error)) {
     return false;
   }
-  return /does not support this tool_choice/i.test(
-    openaiCompatErrorHaystack(error),
+  const haystack = openaiCompatErrorHaystack(error);
+  return THINKING_MODE_TOOL_CHOICE_REJECTION_PATTERNS.some((pattern) =>
+    pattern.test(haystack),
   );
 }
 
@@ -969,7 +977,18 @@ export class OpenAIChatCompletionsProvider implements Provider {
           const thinkingOn = isThinkingEnabledOnWire(params);
           const skipAutoDefault = thinkingOn && toolChoice === "auto";
           const skipAllChoices = thinkingOn && this.omitToolChoiceWhenReasoning;
-          if (!skipAutoDefault && !skipAllChoices) {
+          const skipIncompatibleForcedChoice =
+            thinkingOn &&
+            !supportsForcedToolChoiceWithThinking(
+              this.name,
+              modelOverride ?? this.model,
+            ) &&
+            (toolChoice === "required" || typeof toolChoice === "object");
+          if (
+            !skipAutoDefault &&
+            !skipAllChoices &&
+            !skipIncompatibleForcedChoice
+          ) {
             params.tool_choice = toolChoice;
           }
         }