@vellumai/assistant 0.8.1 → 0.8.3

package/src/providers/model-catalog.ts

@@ -1,4 +1,4 @@
-import { MANAGED_PROVIDER_META } from "./managed-proxy/constants.js";
+import { PLATFORM_PROVIDER_META } from "./platform-proxy/constants.js";
 
 export type LongContextMode =
   | "native-model"
@@ -45,6 +45,8 @@ export interface CatalogModel {
   supportsVision?: boolean;
   supportsToolUse?: boolean;
   pricing?: CatalogModelPricing;
+  /** When set, this model is only visible when the named feature flag is enabled. */
+  featureFlag?: string;
 }
 
 const DEFAULT_CONTEXT_WINDOW_TOKENS = 200000;
@@ -91,12 +93,14 @@ export interface ProviderCatalogEntry {
   /**
    * Whether this provider supports the `platform` auth type (Vellum-managed
    * keys routed through the platform proxy). Derived from
-   * `MANAGED_PROVIDER_META` at catalog build time so the two stay in lock
+   * `PLATFORM_PROVIDER_META` at catalog build time so the two stay in lock
    * step. Clients use this field to hide the "Platform (managed by Vellum)"
    * option from the auth-type dropdown for providers like Fireworks or
    * OpenRouter where managed keys are not available.
    */
-  supportsManagedAuth?: boolean;
+  supportsPlatformAuth?: boolean;
+  /** When set, this provider is only visible when the named feature flag is enabled. */
+  featureFlag?: string;
 }
 
 /**
@@ -184,6 +188,38 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.3,
         },
       },
+      {
+        id: "claude-sonnet-4-5-20250929",
+        displayName: "Claude Sonnet 4.5",
+        contextWindowTokens: 200000,
+        maxOutputTokens: 64000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 3,
+          outputPer1mTokens: 15,
+          cacheWritePer1mTokens: 3.75,
+          cacheReadPer1mTokens: 0.3,
+        },
+      },
+      {
+        id: "claude-opus-4-5-20251101",
+        displayName: "Claude Opus 4.5",
+        contextWindowTokens: 200000,
+        maxOutputTokens: 64000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 5,
+          outputPer1mTokens: 25,
+          cacheWritePer1mTokens: 6.25,
+          cacheReadPer1mTokens: 0.5,
+        },
+      },
       {
         id: "claude-haiku-4-5-20251001",
         displayName: "Claude Haiku 4.5",
@@ -236,8 +272,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.5,
           tiers: [
             {
-              inputTokenThreshold:
-                OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
               inputPer1mTokens: 10,
               outputPer1mTokens: 45,
               cacheReadPer1mTokens: 1,
@@ -261,8 +296,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           outputPer1mTokens: 180.0,
           tiers: [
             {
-              inputTokenThreshold:
-                OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
               inputPer1mTokens: 60,
               outputPer1mTokens: 270,
             },
@@ -286,8 +320,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.25,
           tiers: [
             {
-              inputTokenThreshold:
-                OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
               inputPer1mTokens: 5,
               outputPer1mTokens: 22.5,
               cacheReadPer1mTokens: 0.5,
@@ -547,6 +580,21 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Fireworks Dashboard",
     },
     models: [
+      {
+        id: "accounts/fireworks/models/kimi-k2p6",
+        displayName: "Kimi K2.6",
+        contextWindowTokens: 262144,
+        maxOutputTokens: 32768,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 0.95,
+          outputPer1mTokens: 4.0,
+          cacheReadPer1mTokens: 0.16,
+        },
+      },
       {
         id: "accounts/fireworks/models/kimi-k2p5",
         displayName: "Kimi K2.5",
@@ -561,6 +609,39 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           outputPer1mTokens: 2.5,
         },
       },
+      {
+        id: "accounts/fireworks/models/minimax-m2p7",
+        displayName: "MiniMax M2.7",
+        contextWindowTokens: 196608,
+        maxOutputTokens: 25000,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.3, outputPer1mTokens: 1.2 },
+      },
+      {
+        id: "accounts/fireworks/models/minimax-m2p5",
+        displayName: "MiniMax M2.5",
+        contextWindowTokens: 196608,
+        maxOutputTokens: 25000,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.3, outputPer1mTokens: 1.2 },
+      },
+      {
+        id: "accounts/fireworks/models/deepseek-v4-pro",
+        displayName: "DeepSeek V4 Pro",
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
+      },
     ],
     defaultModel: "accounts/fireworks/models/kimi-k2p5",
     apiKeyUrl: "https://fireworks.ai/account/api-keys",
@@ -634,6 +715,38 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.3,
         },
       },
+      {
+        id: "anthropic/claude-sonnet-4.5",
+        displayName: "Claude Sonnet 4.5",
+        contextWindowTokens: 200000,
+        maxOutputTokens: 64000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 3,
+          outputPer1mTokens: 15,
+          cacheWritePer1mTokens: 3.75,
+          cacheReadPer1mTokens: 0.3,
+        },
+      },
+      {
+        id: "anthropic/claude-opus-4.5",
+        displayName: "Claude Opus 4.5",
+        contextWindowTokens: 200000,
+        maxOutputTokens: 64000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 5,
+          outputPer1mTokens: 25,
+          cacheWritePer1mTokens: 6.25,
+          cacheReadPer1mTokens: 0.5,
+        },
+      },
       {
         id: "anthropic/claude-haiku-4.5",
         displayName: "Claude Haiku 4.5",
@@ -696,6 +809,39 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsToolUse: true,
         pricing: { inputPer1mTokens: 0.27, outputPer1mTokens: 1.1 },
       },
+      {
+        id: "deepseek/deepseek-v4-pro",
+        displayName: "DeepSeek V4 Pro",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 384000,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.435, outputPer1mTokens: 0.87 },
+      },
+      {
+        id: "deepseek/deepseek-v4-flash",
+        displayName: "DeepSeek V4 Flash",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 384000,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.14, outputPer1mTokens: 0.28 },
+      },
+      {
+        id: "deepseek/deepseek-v3.2-speciale",
+        displayName: "DeepSeek V3.2 Speciale",
+        contextWindowTokens: 163840,
+        maxOutputTokens: 163840,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: false,
+        pricing: { inputPer1mTokens: 0.287, outputPer1mTokens: 0.431 },
+      },
       // Qwen
       {
         id: "qwen/qwen3.5-plus-02-15",
@@ -764,6 +910,84 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsToolUse: true,
         pricing: { inputPer1mTokens: 0.6, outputPer1mTokens: 2.5 },
       },
+      // MiniMax
+      {
+        id: "minimax/minimax-m2.7",
+        displayName: "MiniMax M2.7",
+        contextWindowTokens: 196608,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.279, outputPer1mTokens: 1.2 },
+      },
+      {
+        id: "minimax/minimax-m2.5",
+        displayName: "MiniMax M2.5",
+        contextWindowTokens: 196608,
+        maxOutputTokens: 196608,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.15, outputPer1mTokens: 1.15 },
+      },
+      {
+        id: "minimax/minimax-m2.1",
+        displayName: "MiniMax M2.1",
+        contextWindowTokens: 196608,
+        maxOutputTokens: 196608,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.29, outputPer1mTokens: 0.95 },
+      },
+      {
+        id: "minimax/minimax-m2",
+        displayName: "MiniMax M2",
+        contextWindowTokens: 196608,
+        maxOutputTokens: 196608,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.255, outputPer1mTokens: 1.0 },
+      },
+      {
+        id: "minimax/minimax-m2-her",
+        displayName: "MiniMax M2-her",
+        contextWindowTokens: 65536,
+        maxOutputTokens: 2048,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: false,
+        pricing: { inputPer1mTokens: 0.3, outputPer1mTokens: 1.2 },
+      },
+      {
+        id: "minimax/minimax-m1",
+        displayName: "MiniMax M1",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 40000,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.4, outputPer1mTokens: 2.2 },
+      },
+      {
+        id: "minimax/minimax-01",
+        displayName: "MiniMax-01",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 1000000,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: true,
+        supportsToolUse: false,
+        pricing: { inputPer1mTokens: 0.2, outputPer1mTokens: 1.1 },
+      },
       // Mistral
       {
         id: "mistralai/mistral-medium-3",
@@ -838,17 +1062,30 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyUrl: "https://openrouter.ai/keys",
     apiKeyPlaceholder: "sk-or-v1-...",
   },
+  {
+    id: "openai-compatible",
+    displayName: "OpenAI-compatible",
+    subtitle:
+      "Bring your own OpenAI-compatible endpoint (vLLM, LMStudio, Groq, Together, etc.).",
+    setupMode: "api-key",
+    setupHint:
+      "Enter the base URL of your endpoint and at least one model identifier.",
+    apiKeyPlaceholder: "Your provider's API key",
+    featureFlag: "openai-compatible-endpoints",
+    models: [],
+    defaultModel: "",
+  },
 ];
 
 export const PROVIDER_CATALOG: ProviderCatalogEntry[] =
   RAW_PROVIDER_CATALOG.map((entry) => ({
     ...entry,
     models: entry.models.map(catalogModel),
-    // Derive supportsManagedAuth from MANAGED_PROVIDER_META so the catalog
+    // Derive supportsPlatformAuth from PLATFORM_PROVIDER_META so the catalog
     // and the proxy routing table can never drift. Adding a provider to
-    // MANAGED_PROVIDER_META with `managed: true` automatically opts it into
+    // PLATFORM_PROVIDER_META with `managed: true` automatically opts it into
     // the Platform auth-type dropdown in the clients.
-    supportsManagedAuth: MANAGED_PROVIDER_META[entry.id]?.managed === true,
+    supportsPlatformAuth: PLATFORM_PROVIDER_META[entry.id]?.managed === true,
   }));
 
 /** Check if a model ID is in the catalog for a given provider. */

package/src/providers/model-intents.ts

@@ -35,10 +35,10 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
     "vision-optimized": "llama3.2",
   },
   fireworks: {
-    balanced: "accounts/fireworks/models/kimi-k2p5",
+    balanced: "accounts/fireworks/models/kimi-k2p6",
     "latency-optimized": "accounts/fireworks/models/kimi-k2p5",
-    "quality-optimized": "accounts/fireworks/models/kimi-k2p5",
-    "vision-optimized": "accounts/fireworks/models/kimi-k2p5",
+    "quality-optimized": "accounts/fireworks/models/kimi-k2p6",
+    "vision-optimized": "accounts/fireworks/models/kimi-k2p6",
   },
   openrouter: {
     balanced: "anthropic/claude-sonnet-4.6",

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

@@ -0,0 +1,235 @@
+import { describe, expect, test } from "bun:test";
+
+import { OpenAIChatCompletionsProvider } from "../chat-completions-provider.js";
+
+type ReasoningDetail = {
+  type?: string;
+  summary?: string | null;
+  text?: string | null;
+};
+
+type MockChunkDelta = {
+  content?: string | null;
+  reasoning?: string | null;
+  reasoning_content?: string | null;
+  reasoning_details?: ReasoningDetail[] | null;
+};
+
+type MockChunk = {
+  choices: Array<{ delta: MockChunkDelta; finish_reason?: string | null }>;
+  model?: string;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+  };
+};
+
+function makeStream(chunks: MockChunk[]): AsyncIterable<MockChunk> {
+  return {
+    async *[Symbol.asyncIterator]() {
+      for (const c of chunks) yield c;
+    },
+  };
+}
+
+function stubProvider(chunks: MockChunk[]): {
+  provider: OpenAIChatCompletionsProvider;
+  events: Array<{ type: string; thinking?: string; text?: string }>;
+} {
+  const provider = new OpenAIChatCompletionsProvider("test-key", "test-model");
+  // Swap the SDK client for a stub whose chat.completions.create returns our
+  // canned async iterable.
+  (provider as unknown as { client: unknown }).client = {
+    chat: {
+      completions: {
+        create: async () => makeStream(chunks),
+      },
+    },
+  };
+  const events: Array<{ type: string; thinking?: string; text?: string }> = [];
+  (provider as unknown as { __events: typeof events }).__events = events;
+  return { provider, events };
+}
+
+async function runStream(
+  provider: OpenAIChatCompletionsProvider,
+  events: Array<{ type: string; thinking?: string; text?: string }>,
+): Promise<{
+  thinking: string;
+}> {
+  const response = await provider.sendMessage(
+    [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+    undefined,
+    undefined,
+    {
+      onEvent: (e) => {
+        events.push(e as { type: string; thinking?: string; text?: string });
+      },
+    },
+  );
+  const thinkingBlock = response.content.find((b) => b.type === "thinking") as
+    | { type: "thinking"; thinking: string }
+    | undefined;
+  return { thinking: thinkingBlock?.thinking ?? "" };
+}
+
+describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
+  test("emits flat reasoning_content once (Fireworks/DeepSeek/Together/Groq shape)", async () => {
+    const { provider, events } = stubProvider([
+      { choices: [{ delta: { reasoning_content: "hello " } }] },
+      { choices: [{ delta: { reasoning_content: "world" } }] },
+      {
+        choices: [{ delta: {}, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 2 },
+      },
+    ]);
+    const { thinking } = await runStream(provider, events);
+    const deltas = events.filter((e) => e.type === "thinking_delta");
+    expect(deltas.map((d) => d.thinking)).toEqual(["hello ", "world"]);
+    expect(thinking).toBe("hello world");
+  });
+
+  test("emits flat reasoning once (OpenRouter non-Kimi shape)", async () => {
+    const { provider, events } = stubProvider([
+      { choices: [{ delta: { reasoning: "step " } }] },
+      { choices: [{ delta: { reasoning: "two" } }] },
+      {
+        choices: [{ delta: {}, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 2 },
+      },
+    ]);
+    const { thinking } = await runStream(provider, events);
+    const deltas = events.filter((e) => e.type === "thinking_delta");
+    expect(deltas.map((d) => d.thinking)).toEqual(["step ", "two"]);
+    expect(thinking).toBe("step two");
+  });
+
+  test("emits reasoning_details once when only details present", async () => {
+    const { provider, events } = stubProvider([
+      {
+        choices: [
+          {
+            delta: {
+              reasoning_details: [{ type: "reasoning.text", text: "alpha " }],
+            },
+          },
+        ],
+      },
+      {
+        choices: [
+          {
+            delta: {
+              reasoning_details: [
+                { type: "reasoning.summary", summary: "beta" },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        choices: [{ delta: {}, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 2 },
+      },
+    ]);
+    const { thinking } = await runStream(provider, events);
+    const deltas = events.filter((e) => e.type === "thinking_delta");
+    expect(deltas.map((d) => d.thinking)).toEqual(["alpha ", "beta"]);
+    expect(thinking).toBe("alpha beta");
+  });
+
+  test("skips reasoning.encrypted entries entirely", async () => {
+    const { provider, events } = stubProvider([
+      {
+        choices: [
+          {
+            delta: {
+              reasoning_details: [
+                { type: "reasoning.encrypted", text: "opaque" },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        choices: [{ delta: {}, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 2 },
+      },
+    ]);
+    const { thinking } = await runStream(provider, events);
+    const deltas = events.filter((e) => e.type === "thinking_delta");
+    expect(deltas).toEqual([]);
+    expect(thinking).toBe("");
+  });
+
+  test("falls back to flat reasoning when details carry only encrypted entries", async () => {
+    const { provider, events } = stubProvider([
+      {
+        choices: [
+          {
+            delta: {
+              reasoning: "visible ",
+              reasoning_details: [
+                { type: "reasoning.encrypted", text: "opaque" },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        choices: [{ delta: {}, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 2 },
+      },
+    ]);
+    const { thinking } = await runStream(provider, events);
+    const deltas = events.filter((e) => e.type === "thinking_delta");
+    expect(deltas.map((d) => d.thinking)).toEqual(["visible "]);
+    expect(thinking).toBe("visible ");
+  });
+
+  test("does NOT double-emit when Kimi K2.6 mirrors text into both fields", async () => {
+    // OpenRouter Kimi K2.6 with `reasoning.summary` set sends the same token
+    // in both `delta.reasoning` and `delta.reasoning_details[].text`. The
+    // structured field is preferred and the flat field is skipped, so each
+    // token appears exactly once in the output stream.
+    const { provider, events } = stubProvider([
+      {
+        choices: [
+          {
+            delta: {
+              reasoning: "it ",
+              reasoning_details: [{ type: "reasoning.text", text: "it " }],
+            },
+          },
+        ],
+      },
+      {
+        choices: [
+          {
+            delta: {
+              reasoning: "worked",
+              reasoning_details: [{ type: "reasoning.text", text: "worked" }],
+            },
+          },
+        ],
+      },
+      {
+        choices: [
+          {
+            delta: {
+              reasoning: "!",
+              reasoning_details: [{ type: "reasoning.text", text: "!" }],
+            },
+          },
+        ],
+      },
+      {
+        choices: [{ delta: {}, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 3 },
+      },
+    ]);
+    const { thinking } = await runStream(provider, events);
+    const deltas = events.filter((e) => e.type === "thinking_delta");
+    expect(deltas.map((d) => d.thinking)).toEqual(["it ", "worked", "!"]);
+    expect(thinking).toBe("it worked!");
+  });
+});