@vellumai/assistant 0.8.2 → 0.8.4

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

@@ -66,30 +66,56 @@ export interface OpenAIChatCompletionsProviderOptions {
   extraCreateParams?: Record<string, unknown>;
   /** Upper bound for `reasoning_effort` sent on the wire. Defaults to "xhigh"
    *  (OpenAI's current ceiling). Compatibility providers whose APIs only
-   *  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";
+   *  document `low|medium|high` should set this to "high" so Vellum's
+   *  `xhigh`/`max` tiers don't 4xx upstream. Set to "max" for providers like
+   *  Fireworks DeepSeek V4 that accept the full effort range. Subclasses can
+   *  override {@link OpenAIChatCompletionsProvider.resolveMaxReasoningEffort}
+   *  for per-model ceilings. */
+  maxReasoningEffort?: "high" | "xhigh" | "max";
+  /** 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.
- *  OpenAI caps at "xhigh", so our "max" tier collapses to "xhigh". `"none"` is
- *  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<
-  string,
-  NonNullable<
-    OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"]
-  >
-> = {
+/** Wire-level reasoning_effort values. The OpenAI SDK type doesn't include
+ *  `"max"`, but Fireworks accepts it for DeepSeek V4; the assignment to
+ *  `params.reasoning_effort` casts through this union. */
+type ReasoningEffortWire = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+
+const REASONING_EFFORT_RANK: Record<ReasoningEffortWire, number> = {
+  none: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  xhigh: 4,
+  max: 5,
+};
+
+/** Map our internal effort values to a reasoning_effort wire value. `"max"`
+ *  is emitted raw — providers cap it down to their own ceiling
+ *  ({@link OpenAIChatCompletionsProviderOptions.maxReasoningEffort}) at send
+ *  time. `"none"` is passed through explicitly because OpenAI-compatible APIs
+ *  default `reasoning_effort` to `"medium"` when the field is omitted, so the
+ *  user's opt-out is only honored when we send it on the wire. */
+export const EFFORT_TO_REASONING_EFFORT: Record<string, ReasoningEffortWire> = {
   none: "none",
   low: "low",
   medium: "medium",
   high: "high",
   xhigh: "xhigh",
-  max: "xhigh",
+  max: "max",
 };
 
+export function clampReasoningEffort(
+  value: ReasoningEffortWire,
+  ceiling: "high" | "xhigh" | "max",
+): ReasoningEffortWire {
+  return REASONING_EFFORT_RANK[value] > REASONING_EFFORT_RANK[ceiling]
+    ? ceiling
+    : value;
+}
+
 const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
   "image/jpeg",
   "image/png",
@@ -97,6 +123,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.
  *
@@ -111,8 +144,9 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private model: string;
   private streamTimeoutMs: number;
   private extraCreateParams: Record<string, unknown>;
-  private maxReasoningEffort: "high" | "xhigh";
+  private maxReasoningEffort: "high" | "xhigh" | "max";
   private requestHeaders: Record<string, string>;
+  private parseThinkTags: boolean;
 
   constructor(
     apiKey: string,
@@ -130,6 +164,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,14 +198,24 @@ 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) {
-        params.reasoning_effort =
-          reasoningEffort === "xhigh" && this.maxReasoningEffort === "high"
-            ? "high"
-            : reasoningEffort;
+      if (reasoningEffort && typeof nestedReasoningEffort !== "string") {
+        const ceiling = this.resolveMaxReasoningEffort(
+          modelOverride ?? this.model,
+        );
+        params.reasoning_effort = clampReasoningEffort(
+          reasoningEffort,
+          ceiling,
+        ) as OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"];
       }
 
       if (tools && tools.length > 0) {
@@ -189,6 +234,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 +323,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 +421,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>;
@@ -393,6 +571,18 @@ export class OpenAIChatCompletionsProvider implements Provider {
     return this.extraCreateParams;
   }
 
+  /**
+   * Per-request reasoning_effort ceiling. Defaults to the provider-wide
+   * `maxReasoningEffort` from constructor options. Subclasses (e.g. Fireworks)
+   * override to consult the model catalog so per-model accepted ranges are
+   * respected.
+   */
+  protected resolveMaxReasoningEffort(
+    _model: string,
+  ): "high" | "xhigh" | "max" {
+    return this.maxReasoningEffort;
+  }
+
   /** Convert neutral messages + system prompt to OpenAI message format. */
   private toOpenAIMessages(
     messages: Message[],

package/src/providers/openai/responses-provider.ts

@@ -23,6 +23,9 @@ export interface OpenAIResponsesProviderOptions {
   providerLabel?: string;
   streamTimeoutMs?: number;
   useNativeWebSearch?: boolean;
+  /** When true, target the Codex subscription endpoint and strip fields it
+   *  rejects (`max_output_tokens`, `metadata`). */
+  codexSubscription?: boolean;
 }
 
 /** Map our internal effort values to the Responses API reasoning.effort parameter.
@@ -103,6 +106,7 @@ export class OpenAIResponsesProvider implements Provider {
   private model: string;
   private streamTimeoutMs: number;
   private useNativeWebSearch: boolean;
+  private codexSubscription: boolean;
 
   constructor(
     apiKey: string,
@@ -111,9 +115,12 @@ export class OpenAIResponsesProvider implements Provider {
   ) {
     this.name = options.providerName ?? "openai";
     this.providerLabel = options.providerLabel ?? "OpenAI";
+    this.codexSubscription = options.codexSubscription ?? false;
     this.client = new OpenAI({
       apiKey,
-      baseURL: options.baseURL,
+      baseURL: this.codexSubscription
+        ? "https://chatgpt.com/backend-api/codex"
+        : options.baseURL,
     });
     this.model = model;
     this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
@@ -142,7 +149,6 @@ export class OpenAIResponsesProvider implements Provider {
       const params: Record<string, unknown> = {
         model: modelOverride ?? this.model,
         input,
-        store: false,
       };
 
       if (systemPrompt) {
@@ -152,7 +158,7 @@ export class OpenAIResponsesProvider implements Provider {
         );
       }
 
-      if (maxTokens) {
+      if (maxTokens && !this.codexSubscription) {
         params.max_output_tokens = maxTokens;
       }
 

package/src/providers/openrouter/client.ts

@@ -1,6 +1,10 @@
 import { ProviderError } from "../../util/errors.js";
 import { AnthropicProvider } from "../anthropic/client.js";
-import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import {
+  clampReasoningEffort,
+  EFFORT_TO_REASONING_EFFORT,
+  OpenAIChatCompletionsProvider,
+} from "../openai/chat-completions-provider.js";
 import { isThinkingConfigEnabled } from "../thinking-config.js";
 import type {
   Message,
@@ -53,6 +57,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 +183,33 @@ 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 = clampReasoningEffort(
+        mappedEffort,
+        this.resolveMaxReasoningEffort(this.resolveEffectiveModel(options)),
+      );
+    }
+    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 },
 };