@vellumai/assistant 0.8.4 → 0.8.6

package/src/providers/minimax/client.ts

@@ -0,0 +1,106 @@
+import OpenAI from "openai";
+
+import { getLogger } from "../../util/logger.js";
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+
+const log = getLogger("minimax-client");
+
+/** Validation-specific timeout (10s) so a stalled network doesn't block key submission. */
+const VALIDATION_TIMEOUT_MS = 10_000;
+
+export interface MinimaxProviderOptions {
+  apiKey?: string;
+  baseURL?: string;
+  streamTimeoutMs?: number;
+}
+
+const DEFAULT_MINIMAX_BASE_URL = "https://api.minimax.io/v1";
+const FALLBACK_MINIMAX_BASE_URL = "https://api.minimaxi.com/v1";
+
+/**
+ * Validate a MiniMax API key by testing against the default URL first,
+ * then the fallback URL if the default fails. Both URLs must fail with
+ * definitive errors (401/403) for the key to be rejected. Transient errors
+ * (429, 5xx, network) allow the key to be stored.
+ */
+export async function validateMinimaxApiKey(
+  apiKey: string,
+): Promise<{ valid: true } | { valid: false; reason: string }> {
+  // Try default URL first
+  const defaultResult = await tryValidate(apiKey, DEFAULT_MINIMAX_BASE_URL);
+  if (defaultResult.valid && !defaultResult.transient) {
+    return { valid: true };
+  }
+
+  // Default failed or was transient — try fallback URL
+  const fallbackResult = await tryValidate(apiKey, FALLBACK_MINIMAX_BASE_URL);
+  if (fallbackResult.valid) {
+    return { valid: true };
+  }
+
+  // Both URLs failed definitively — reject the key
+  return { valid: false, reason: fallbackResult.reason };
+}
+
+async function tryValidate(
+  apiKey: string,
+  baseURL: string,
+): Promise<
+  | { valid: true; transient: false }
+  | { valid: true; transient: true }
+  | { valid: false; reason: string }
+> {
+  try {
+    const client = new OpenAI({
+      apiKey,
+      baseURL,
+      timeout: VALIDATION_TIMEOUT_MS,
+      maxRetries: 0,
+    });
+    await client.models.list();
+    return { valid: true, transient: false };
+  } catch (error) {
+    if (error instanceof OpenAI.APIError) {
+      if (error.status === 401) {
+        return { valid: false, reason: "API key is invalid or expired." };
+      }
+      if (error.status === 403) {
+        return {
+          valid: false,
+          reason: `MiniMax API error (${error.status}): ${error.message}`,
+        };
+      }
+      // Transient errors (429, 5xx, etc.) — try the other URL
+      log.warn(
+        { status: error.status, baseURL },
+        "MiniMax API returned a transient error during key validation — trying fallback",
+      );
+      return { valid: true, transient: true };
+    }
+    // Network errors — try the other URL
+    log.warn(
+      {
+        error: error instanceof Error ? error.message : String(error),
+        baseURL,
+      },
+      "Network error during MiniMax key validation — trying fallback",
+    );
+    return { valid: true, transient: true };
+  }
+}
+
+export class MinimaxProvider extends OpenAIChatCompletionsProvider {
+  constructor(
+    apiKey: string,
+    model: string,
+    options: MinimaxProviderOptions = {},
+  ) {
+    const baseURL = options.baseURL?.trim() || DEFAULT_MINIMAX_BASE_URL;
+    super(apiKey, model, {
+      baseURL,
+      providerName: "minimax",
+      providerLabel: "MiniMax",
+      streamTimeoutMs: options.streamTimeoutMs,
+    });
+  }
+}

package/src/providers/model-catalog.ts

@@ -144,6 +144,23 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Anthropic Console",
     },
     models: [
+      {
+        id: "claude-opus-4-8",
+        displayName: "Claude Opus 4.8",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 5,
+          outputPer1mTokens: 25,
+          cacheWritePer1mTokens: 6.25,
+          cacheReadPer1mTokens: 0.5,
+        },
+      },
       {
         id: "claude-opus-4-7",
         displayName: "Claude Opus 4.7",
@@ -244,7 +261,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         },
       },
     ],
-    defaultModel: "claude-opus-4-7",
+    defaultModel: "claude-opus-4-8",
     apiKeyUrl: "https://console.anthropic.com/settings/keys",
     apiKeyPlaceholder: "sk-ant-api03-...",
   },
@@ -493,6 +510,21 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.025,
         },
       },
+      {
+        id: "gemini-3.1-flash-lite",
+        displayName: "Gemini 3.1 Flash-Lite",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 0.25,
+          outputPer1mTokens: 1.5,
+          cacheReadPer1mTokens: 0.025,
+        },
+      },
       {
         id: "gemini-2.5-flash",
         displayName: "Gemini 2.5 Flash",
@@ -688,6 +720,23 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // OpenRouter proxies anthropic/* through Anthropic's Messages API, so
       // prompt caching and cache TTL metadata pass through unchanged and
       // billing matches Anthropic's direct rates.
+      {
+        id: "anthropic/claude-opus-4.8",
+        displayName: "Claude Opus 4.8",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 5,
+          outputPer1mTokens: 25,
+          cacheWritePer1mTokens: 6.25,
+          cacheReadPer1mTokens: 0.5,
+        },
+      },
       {
         id: "anthropic/claude-opus-4.7",
         displayName: "Claude Opus 4.7",
@@ -1122,6 +1171,34 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     models: [],
     defaultModel: "",
   },
+  {
+    id: "minimax",
+    displayName: "MiniMax",
+    subtitle: "MiniMax AI models. Requires a MiniMax API key.",
+    setupMode: "api-key",
+    setupHint: "Enter your MiniMax API key to enable MiniMax models.",
+    envVar: "MINIMAX_API_KEY",
+    credentialsGuide: {
+      description: "Sign in to the MiniMax dashboard and create an API key.",
+      url: "https://platform.minimax.io/",
+      linkLabel: "Open MiniMax Dashboard",
+    },
+    models: [
+      {
+        id: "MiniMax-M2.7",
+        displayName: "MiniMax M2.7",
+        contextWindowTokens: 200000,
+        maxOutputTokens: 16384,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+      },
+    ],
+    defaultModel: "MiniMax-M2.7",
+    apiKeyUrl: "https://platform.minimax.io/",
+    apiKeyPlaceholder: "sk-cp-...",
+  },
 ];
 
 export const PROVIDER_CATALOG: ProviderCatalogEntry[] =

package/src/providers/model-intents.ts

@@ -13,7 +13,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   anthropic: {
     balanced: "claude-sonnet-4-6",
     "latency-optimized": "claude-haiku-4-5-20251001",
-    "quality-optimized": "claude-opus-4-7",
+    "quality-optimized": "claude-opus-4-8",
     "vision-optimized": "claude-opus-4-6",
   },
   openai: {
@@ -24,7 +24,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   gemini: {
     balanced: "gemini-3-flash-preview",
-    "latency-optimized": "gemini-3.1-flash-lite-preview",
+    "latency-optimized": "gemini-3.1-flash-lite",
     "quality-optimized": "gemini-3.1-pro-preview",
     "vision-optimized": "gemini-3-flash-preview",
   },
@@ -43,12 +43,12 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   openrouter: {
     balanced: "anthropic/claude-sonnet-4.6",
     "latency-optimized": "anthropic/claude-haiku-4.5",
-    "quality-optimized": "anthropic/claude-opus-4.7",
+    "quality-optimized": "anthropic/claude-opus-4.8",
     "vision-optimized": "anthropic/claude-opus-4.6",
   },
 };
 
-const FALLBACK_DEFAULT_MODEL = "claude-opus-4-7";
+const FALLBACK_DEFAULT_MODEL = "claude-opus-4-8";
 
 const MODEL_INTENTS = new Set<ModelIntent>([
   "balanced",

package/src/providers/openai/__tests__/api-error-detail.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test";
+
+import OpenAI from "openai";
+
+import { extractApiErrorDetail } from "../chat-completions-provider.js";
+
+/**
+ * Construct a real `OpenAI.APIError` so production code paths that use
+ * `instanceof OpenAI.APIError` and SDK-defined getters keep matching.
+ */
+function buildApiError(
+  status: number,
+  body: unknown,
+  headers?: Headers,
+): InstanceType<typeof OpenAI.APIError> {
+  return new OpenAI.APIError(
+    status,
+    body as Record<string, unknown>,
+    undefined,
+    headers ?? new Headers(),
+  );
+}
+
+describe("extractApiErrorDetail", () => {
+  test("serializes a structured body so logs show the upstream error", () => {
+    // This is the canonical OpenRouter shape that motivated the helper:
+    // the SDK's `error.message` collapses to "400 Provider returned error"
+    // and the real detail lives nested under `error.metadata.raw`.
+    const err = buildApiError(400, {
+      error: {
+        code: 400,
+        message: "Provider returned error",
+        metadata: {
+          raw: "messages.4: tool_use_id must reference a prior tool_use block",
+          provider_name: "Anthropic",
+        },
+      },
+    });
+    const { detail, requestId } = extractApiErrorDetail(err);
+    expect(detail).toContain("Provider returned error");
+    expect(detail).toContain("tool_use_id must reference a prior tool_use");
+    expect(detail).toContain("Anthropic");
+    expect(requestId).toBeUndefined();
+  });
+
+  test("surfaces the upstream request id when present in headers", () => {
+    const headers = new Headers({ "x-request-id": "req_abc123" });
+    const err = buildApiError(
+      400,
+      { error: { message: "Provider returned error" } },
+      headers,
+    );
+    const { requestId } = extractApiErrorDetail(err);
+    expect(requestId).toBe("req_abc123");
+  });
+
+  test("falls back to x-openrouter-request-id when x-request-id is absent", () => {
+    const headers = new Headers({
+      "x-openrouter-request-id": "gen-or-xyz",
+    });
+    const err = buildApiError(
+      400,
+      { error: { message: "Provider returned error" } },
+      headers,
+    );
+    const { requestId } = extractApiErrorDetail(err);
+    expect(requestId).toBe("gen-or-xyz");
+  });
+
+  test("returns empty detail when the body is missing", () => {
+    // The SDK constructs an APIError even when the upstream response had
+    // no JSON body (e.g. network-layer 5xx). The helper must degrade
+    // gracefully rather than emit `undefined` or `null` strings.
+    const err = buildApiError(500, undefined);
+    const { detail, requestId } = extractApiErrorDetail(err);
+    expect(detail).toBe("");
+    expect(requestId).toBeUndefined();
+  });
+
+  test("returns empty detail when the body serializes to an empty object", () => {
+    // `{}` carries zero signal and just adds noise to log lines.
+    const err = buildApiError(429, {});
+    const { detail } = extractApiErrorDetail(err);
+    expect(detail).toBe("");
+  });
+
+  test("truncates very long bodies with an ellipsis", () => {
+    const huge = "X".repeat(5000);
+    const err = buildApiError(400, { error: { message: huge } });
+    const { detail } = extractApiErrorDetail(err);
+    // Cap is 2000 chars; the helper appends a single-char ellipsis when truncating.
+    expect(detail.length).toBeLessThanOrEqual(2001);
+    expect(detail.endsWith("…")).toBe(true);
+  });
+
+  test("preserves string bodies verbatim (no double-encoding)", () => {
+    // Some providers return a non-JSON body (HTML error page, plain text).
+    // The SDK stores it on `error.error` as a string in that case.
+    const err = buildApiError(502, "upstream timeout");
+    const { detail } = extractApiErrorDetail(err);
+    expect(detail).toBe("upstream timeout");
+  });
+
+  test("returns empty detail when JSON.stringify throws (cyclic body)", () => {
+    // Pathological body — should not propagate the TypeError to callers.
+    // OpenAI's `APIError` constructor itself JSON.stringifies the body to
+    // build its own `.message`, so we can't get to this branch via the SDK
+    // constructor; build a structural stand-in instead.
+    const cyclic: Record<string, unknown> = {};
+    cyclic.self = cyclic;
+    const stub = {
+      status: 400,
+      message: "synthetic",
+      headers: new Headers(),
+      error: cyclic,
+    } as unknown as InstanceType<typeof OpenAI.APIError>;
+    const { detail } = extractApiErrorDetail(stub);
+    expect(detail).toBe("");
+  });
+});

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

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
-import { OpenAIChatCompletionsProvider } from "../chat-completions-provider.js";
+import {
+  OpenAIChatCompletionsProvider,
+  type OpenAIChatCompletionsProviderOptions,
+} from "../chat-completions-provider.js";
 
 type ReasoningDetail = {
   type?: string;
@@ -32,23 +35,35 @@ function makeStream(chunks: MockChunk[]): AsyncIterable<MockChunk> {
   };
 }
 
-function stubProvider(chunks: MockChunk[]): {
+function stubProvider(
+  chunks: MockChunk[],
+  options?: OpenAIChatCompletionsProviderOptions,
+): {
   provider: OpenAIChatCompletionsProvider;
   events: Array<{ type: string; thinking?: string; text?: string }>;
+  requests: unknown[];
 } {
-  const provider = new OpenAIChatCompletionsProvider("test-key", "test-model");
+  const provider = new OpenAIChatCompletionsProvider(
+    "test-key",
+    "test-model",
+    options,
+  );
+  const requests: unknown[] = [];
   // 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),
+        create: async (params: unknown) => {
+          requests.push(params);
+          return makeStream(chunks);
+        },
       },
     },
   };
   const events: Array<{ type: string; thinking?: string; text?: string }> = [];
   (provider as unknown as { __events: typeof events }).__events = events;
-  return { provider, events };
+  return { provider, events, requests };
 }
 
 async function runStream(
@@ -232,4 +247,141 @@ describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
     expect(deltas.map((d) => d.thinking)).toEqual(["it ", "worked", "!"]);
     expect(thinking).toBe("it worked!");
   });
+
+  test("round-trips prior assistant thinking as reasoning_content when field is set", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "continued" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 4, completion_tokens: 2 },
+        },
+      ],
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "first question" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "hidden chain state", signature: "" },
+          { type: "text", text: "first answer" },
+        ],
+      },
+      { role: "user", content: [{ type: "text", text: "follow up" }] },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        content: string | null;
+        reasoning_content?: string;
+      }>;
+    };
+    const assistantMsg = params.messages.find((m) => m.role === "assistant");
+    expect(assistantMsg).toEqual({
+      role: "assistant",
+      content: "first answer",
+      reasoning_content: "hidden chain state",
+    });
+  });
+
+  test("uses reasoning field for OpenRouter-style round-trip", 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: "thinking", thinking: "visible summary", signature: "" },
+          { type: "text", text: "answer" },
+        ],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        reasoning?: string;
+        reasoning_content?: string;
+      }>;
+    };
+    expect(params.messages[0].reasoning).toBe("visible summary");
+    expect(params.messages[0].reasoning_content).toBeUndefined();
+  });
+
+  test("drops thinking blocks when assistantReasoningField is unset", async () => {
+    const { provider, requests } = stubProvider([
+      {
+        choices: [{ delta: { content: "reply" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 2, completion_tokens: 1 },
+      },
+    ]);
+
+    await provider.sendMessage([
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "should be dropped", signature: "" },
+          { type: "text", text: "visible" },
+        ],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        content: string | null;
+        reasoning?: string;
+        reasoning_content?: string;
+      }>;
+    };
+    const assistantMsg = params.messages[0];
+    expect(assistantMsg.content).toBe("visible");
+    expect(assistantMsg.reasoning).toBeUndefined();
+    expect(assistantMsg.reasoning_content).toBeUndefined();
+  });
+
+  test("skips Anthropic-originated thinking blocks (with signatures)", 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: "anthropic thinking",
+            signature: "sig-abc",
+          },
+          { type: "thinking", thinking: "deepseek thinking", signature: "" },
+          { type: "text", text: "answer" },
+        ],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        reasoning_content?: string;
+      }>;
+    };
+    expect(params.messages[0].reasoning_content).toBe("deepseek thinking");
+  });
 });