@vellumai/assistant 0.8.2 → 0.8.3

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!");
+  });
+});

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

@@ -69,6 +69,10 @@ export interface OpenAIChatCompletionsProviderOptions {
    *  document `low|medium|high` (e.g. Fireworks) should set this to "high" so
    *  Vellum's `xhigh`/`max` tiers don't 4xx upstream. */
   maxReasoningEffort?: "high" | "xhigh";
+  /** Parse `<think>...</think>` tags from the content stream into thinking
+   *  blocks. MiniMax and similar providers embed reasoning inside XML-style
+   *  tags in the regular content field rather than using `reasoning_content`. */
+  parseThinkTags?: boolean;
 }
 
 /** Map our internal effort values to OpenAI's reasoning_effort parameter.
@@ -76,7 +80,7 @@ export interface OpenAIChatCompletionsProviderOptions {
  *  passed through explicitly because OpenAI defaults `reasoning_effort` to
  *  "medium" when the field is omitted — the user's opt-out is only honored
  *  when we send it on the wire. */
-const EFFORT_TO_REASONING_EFFORT: Record<
+export const EFFORT_TO_REASONING_EFFORT: Record<
   string,
   NonNullable<
     OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"]
@@ -97,6 +101,13 @@ const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
   "image/webp",
 ]);
 
+function partialTagSuffix(text: string, tag: string): number {
+  for (let len = Math.min(text.length, tag.length - 1); len > 0; len--) {
+    if (text.endsWith(tag.substring(0, len))) return len;
+  }
+  return 0;
+}
+
 /**
  * OpenAI-compatible chat-completions transport.
  *
@@ -113,6 +124,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private extraCreateParams: Record<string, unknown>;
   private maxReasoningEffort: "high" | "xhigh";
   private requestHeaders: Record<string, string>;
+  private parseThinkTags: boolean;
 
   constructor(
     apiKey: string,
@@ -130,6 +142,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     this.extraCreateParams = options.extraCreateParams ?? {};
     this.maxReasoningEffort = options.maxReasoningEffort ?? "xhigh";
     this.requestHeaders = options.requestHeaders ?? {};
+    this.parseThinkTags = options.parseThinkTags ?? false;
   }
 
   async sendMessage(
@@ -163,10 +176,17 @@ export class OpenAIChatCompletionsProvider implements Provider {
         params.max_completion_tokens = maxTokens;
       }
 
+      // Subclasses (OpenRouter) may already have nested effort under
+      // `reasoning.effort` via `buildExtraCreateParams`. Skip the flat
+      // `reasoning_effort` assignment in that case to avoid sending both forms,
+      // which OpenRouter rejects on reasoning models.
+      const nestedReasoningEffort = (
+        params as { reasoning?: { effort?: unknown } }
+      ).reasoning?.effort;
       const reasoningEffort = effort
         ? EFFORT_TO_REASONING_EFFORT[effort]
         : undefined;
-      if (reasoningEffort) {
+      if (reasoningEffort && typeof nestedReasoningEffort !== "string") {
         params.reasoning_effort =
           reasoningEffort === "xhigh" && this.maxReasoningEffort === "high"
             ? "high"
@@ -189,6 +209,68 @@ export class OpenAIChatCompletionsProvider implements Provider {
 
       // Accumulate the response from chunks
       let contentText = "";
+      let reasoningText = "";
+      let insideThinkBlock = false;
+      let pendingContent = "";
+
+      const flushPendingContent = (final: boolean): void => {
+        while (pendingContent.length > 0) {
+          if (insideThinkBlock) {
+            const closeIdx = pendingContent.indexOf("</think>");
+            if (closeIdx >= 0) {
+              const thinking = pendingContent.substring(0, closeIdx);
+              if (thinking) {
+                reasoningText += thinking;
+                onEvent?.({ type: "thinking_delta", thinking });
+              }
+              insideThinkBlock = false;
+              pendingContent = pendingContent.substring(
+                closeIdx + "</think>".length,
+              );
+            } else {
+              const partial = final
+                ? 0
+                : partialTagSuffix(pendingContent, "</think>");
+              const safeLen = pendingContent.length - partial;
+              if (safeLen > 0) {
+                const thinking = pendingContent.substring(0, safeLen);
+                reasoningText += thinking;
+                onEvent?.({ type: "thinking_delta", thinking });
+              }
+              pendingContent =
+                partial > 0 ? pendingContent.substring(safeLen) : "";
+              break;
+            }
+          } else {
+            const openIdx = pendingContent.indexOf("<think>");
+            if (openIdx >= 0) {
+              const text = pendingContent.substring(0, openIdx);
+              if (text) {
+                contentText += text;
+                onEvent?.({ type: "text_delta", text });
+              }
+              insideThinkBlock = true;
+              pendingContent = pendingContent.substring(
+                openIdx + "<think>".length,
+              );
+            } else {
+              const partial = final
+                ? 0
+                : partialTagSuffix(pendingContent, "<think>");
+              const safeLen = pendingContent.length - partial;
+              if (safeLen > 0) {
+                const t = pendingContent.substring(0, safeLen);
+                contentText += t;
+                onEvent?.({ type: "text_delta", text: t });
+              }
+              pendingContent =
+                partial > 0 ? pendingContent.substring(safeLen) : "";
+              break;
+            }
+          }
+        }
+      };
+
       const toolCallMap = new Map<
         number,
         { id: string; name: string; args: string }
@@ -216,8 +298,62 @@ export class OpenAIChatCompletionsProvider implements Provider {
           const choice = chunk.choices[0];
           if (choice) {
             if (choice.delta.content) {
-              contentText += choice.delta.content;
-              onEvent?.({ type: "text_delta", text: choice.delta.content });
+              if (this.parseThinkTags) {
+                pendingContent += choice.delta.content;
+                flushPendingContent(false);
+              } else {
+                contentText += choice.delta.content;
+                onEvent?.({ type: "text_delta", text: choice.delta.content });
+              }
+            }
+
+            // Compatibility providers disagree on the field name: Fireworks /
+            // DeepSeek / Together / Groq stream `reasoning_content`; OpenRouter
+            // (per its ChatAssistantMessage spec) streams `reasoning`, and for
+            // reasoning summaries (e.g. Kimi K2.6) also populates
+            // `delta.reasoning_details[]` (entries are `reasoning.summary`,
+            // `reasoning.text`, or opaque `reasoning.encrypted`).
+            //
+            // Kimi K2.6 mirrors the same token into BOTH `delta.reasoning` and
+            // `delta.reasoning_details[].text` per chunk — prefer details when
+            // they carry visible text, otherwise fall through to the flat
+            // field. The encrypted-only case must fall through too, so the
+            // flat `reasoning` field isn't silently dropped.
+            const deltaWithReasoning = choice.delta as {
+              reasoning?: string | null;
+              reasoning_content?: string | null;
+              reasoning_details?: Array<{
+                type?: string;
+                summary?: string | null;
+                text?: string | null;
+              }> | null;
+            };
+
+            let sawVisibleDetail = false;
+            const reasoningDetails = deltaWithReasoning.reasoning_details;
+            if (Array.isArray(reasoningDetails)) {
+              for (const entry of reasoningDetails) {
+                if (entry.type === "reasoning.encrypted") continue;
+                const piece = entry.summary ?? entry.text;
+                if (piece) {
+                  sawVisibleDetail = true;
+                  reasoningText += piece;
+                  onEvent?.({ type: "thinking_delta", thinking: piece });
+                }
+              }
+            }
+
+            if (!sawVisibleDetail) {
+              const reasoningContent =
+                deltaWithReasoning.reasoning_content ??
+                deltaWithReasoning.reasoning;
+              if (reasoningContent) {
+                reasoningText += reasoningContent;
+                onEvent?.({
+                  type: "thinking_delta",
+                  thinking: reasoningContent,
+                });
+              }
             }
 
             if (choice.delta.tool_calls) {
@@ -260,10 +396,27 @@ export class OpenAIChatCompletionsProvider implements Provider {
         cleanupTimeout();
       }
 
+      if (this.parseThinkTags && pendingContent) {
+        flushPendingContent(true);
+      }
+
       // Build content blocks
+      const finalReasoning = this.parseThinkTags
+        ? reasoningText.trim()
+        : reasoningText;
+      const finalContent = this.parseThinkTags
+        ? contentText.trim()
+        : contentText;
       const content: ContentBlock[] = [];
-      if (contentText) {
-        content.push({ type: "text", text: contentText });
+      if (finalReasoning) {
+        content.push({
+          type: "thinking",
+          thinking: finalReasoning,
+          signature: "",
+        });
+      }
+      if (finalContent) {
+        content.push({ type: "text", text: finalContent });
       }
       for (const [, tc] of toolCallMap) {
         let input: Record<string, unknown>;

package/src/providers/openrouter/client.ts

@@ -1,6 +1,9 @@
 import { ProviderError } from "../../util/errors.js";
 import { AnthropicProvider } from "../anthropic/client.js";
-import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import {
+  EFFORT_TO_REASONING_EFFORT,
+  OpenAIChatCompletionsProvider,
+} from "../openai/chat-completions-provider.js";
 import { isThinkingConfigEnabled } from "../thinking-config.js";
 import type {
   Message,
@@ -53,6 +56,25 @@ export function extractOnlyList(config: unknown): string[] {
   return only.filter((x): x is string => typeof x === "string" && x.length > 0);
 }
 
+// OpenRouter's `reasoning.summary` field controls whether reasoning models emit
+// a human-readable summary alongside (or instead of) encrypted reasoning blocks.
+// Models like Kimi K2.6 return only encrypted `reasoning_details` unless a
+// summary level is requested, so the stream carries no visible thinking content.
+// Default to "detailed" so users see thinking by default; allow per-call
+// override via `config.openrouter.reasoning.summary`. Per OpenRouter's
+// ChatRequestReasoning schema, valid values are "auto" | "concise" | "detailed".
+const VALID_REASONING_SUMMARIES = new Set(["auto", "concise", "detailed"]);
+
+function extractReasoningSummaryOverride(config: unknown): string | undefined {
+  const cfg = config as
+    | { openrouter?: { reasoning?: { summary?: unknown } } }
+    | undefined;
+  const summary = cfg?.openrouter?.reasoning?.summary;
+  return typeof summary === "string" && VALID_REASONING_SUMMARIES.has(summary)
+    ? summary
+    : undefined;
+}
+
 /**
  * Rewrite `options.config` for the Anthropic-compat path so OpenRouter's
  * `provider: { only: [...] }` body field travels through `AnthropicProvider`'s
@@ -160,14 +182,30 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
   // OpenRouter's unified `reasoning` parameter controls extended thinking on
   // its OpenAI-compatible endpoint. Anthropic models skip this path entirely and
   // go through AnthropicProvider, which receives the native `thinking` object.
+  //
+  // `effort` nests under `reasoning` here (rather than flat `reasoning_effort`)
+  // because OpenRouter's documented `ChatRequestReasoning` shape is the union of
+  // { effort, summary }. `summary` is required for models like Kimi K2.6 that
+  // would otherwise return only encrypted reasoning blocks; we default to
+  // "detailed" and let callers override via `config.openrouter.reasoning.summary`.
   protected override buildExtraCreateParams(
     options?: SendMessageOptions,
   ): Record<string, unknown> {
     const config = options?.config as Record<string, unknown> | undefined;
     const thinkingEnabled = isThinkingConfigEnabled(config?.thinking);
-    const extras: Record<string, unknown> = {
-      reasoning: { enabled: thinkingEnabled },
-    };
+    const effort = config?.effort as string | undefined;
+    const mappedEffort = effort
+      ? EFFORT_TO_REASONING_EFFORT[effort]
+      : undefined;
+    const summaryOverride = extractReasoningSummaryOverride(config);
+    const reasoning: Record<string, unknown> = { enabled: thinkingEnabled };
+    if (mappedEffort) {
+      reasoning.effort = mappedEffort;
+    }
+    if (thinkingEnabled) {
+      reasoning.summary = summaryOverride ?? "detailed";
+    }
+    const extras: Record<string, unknown> = { reasoning };
     const only = extractOnlyList(config);
     if (only.length > 0) {
       const existingProvider = (config?.provider ?? {}) as Record<

package/src/providers/platform-proxy/constants.ts

@@ -43,14 +43,13 @@ export const PLATFORM_PROVIDER_META: Record<string, ManagedProviderMeta> = {
   },
   fireworks: {
     name: "fireworks",
-    managed: false,
+    managed: true,
+    proxyPath: "/v1/runtime-proxy/fireworks",
   },
   openrouter: {
     name: "openrouter",
     managed: false,
   },
   ollama: { name: "ollama", managed: false },
-  zai: { name: "zai", managed: false },
-  deepseek: { name: "deepseek", managed: false },
-  minimax: { name: "minimax", managed: false },
+  "openai-compatible": { name: "openai-compatible", managed: false },
 };

package/src/providers/provider-catalog-visibility.ts

@@ -32,5 +32,7 @@ export function getVisibleProviderCatalog(
       if (visibleModels.length === entry.models.length) return entry;
       return { ...entry, models: visibleModels };
     })
-    .filter((entry) => entry.models.length > 0);
+    .filter(
+      (entry) => entry.models.length > 0 || entry.defaultModel === "",
+    );
 }

package/src/providers/provider-send-message.ts

@@ -7,8 +7,10 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import { getDb } from "../memory/db-connection.js";
 import { getLogger } from "../util/logger.js";
 import { tryResolveProviderForConnectionName } from "./connection-resolution.js";
+import { listConnections } from "./inference/connections.js";
 import { initializeProviders, listProviders } from "./registry.js";
 import type {
   ContentBlock,
@@ -110,22 +112,35 @@ export async function resolveConfiguredProvider(
 
   const resolved = resolveCallSiteConfig(callSite, config.llm, opts);
   const inferenceProvider = resolved.provider;
-  const connectionName = resolved.provider_connection;
+  let connectionName = resolved.provider_connection;
 
   // Connection-aware path: every dispatch goes through `provider_connection`.
   // The boot-time backfill ensures every profile has one in production.
-  // When unset (test envs that skip backfill, freshly-installed configs
-  // not yet backfilled, or users who manually cleared the field), we
-  // return null so callsites with deterministic fallbacks (invite
-  // instructions, telegram username resolution, etc.) keep working.
-  // Hard config errors — connection lookup failure, provider mismatch —
-  // still throw via `tryResolveProviderForConnectionName` below.
+  // When unset (profile set provider with "Any active" connection, test envs
+  // that skip backfill, freshly-installed configs not yet backfilled, or
+  // users who manually cleared the field), try to auto-resolve from the
+  // provider before falling back to null.
   if (!connectionName) {
-    log.debug(
-      { callSite, inferenceProvider },
-      "resolveCallSiteConfig yielded no provider_connection — returning null so callsite can fall back",
-    );
-    return null;
+    if (inferenceProvider) {
+      try {
+        const candidates = listConnections(getDb(), {
+          provider: inferenceProvider,
+        });
+        const active = candidates.find((c) => c.status === "active");
+        if (active) {
+          connectionName = active.name;
+        }
+      } catch {
+        // DB not available — fall through to the existing null-return path.
+      }
+    }
+    if (!connectionName) {
+      log.debug(
+        { callSite, inferenceProvider },
+        "resolveCallSiteConfig yielded no provider_connection — returning null so callsite can fall back",
+      );
+      return null;
+    }
   }
 
   const connectionProvider = await tryResolveProviderForConnectionName(