Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

8.5 KB
Raw Blame
const test = require("node:test");
const assert = require("node:assert/strict");

// Requires Node's native TypeScript type-stripping (Node >= 22.6 with
// --experimental-strip-types, on by default in Node 23.6+/24). CI runs Node 24.

const load = () => import("../../src/services/ai/thinkingSuppressionDialects.ts");

test("groq qwen models get reasoning_effort none and never chat_template_kwargs", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "groq", "qwen/qwen3-32b");

  assert.deepEqual(body, { reasoning_effort: "none" });
  assert.ok(!("chat_template_kwargs" in body), "Groq rejects chat_template_kwargs with a 400");
});

test("groq gpt-oss models get reasoning_effort low, the lowest value that family accepts", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "groq", "openai/gpt-oss-120b");

  assert.deepEqual(body, { reasoning_effort: "low" });
  assert.ok(!("chat_template_kwargs" in body), "Groq rejects chat_template_kwargs with a 400");
});

test("groq model family matching is case insensitive", async () => {
  const { suppressThinking } = await load();

  const qwen = {};
  suppressThinking(qwen, "groq", "Qwen/Qwen3-32B");
  assert.equal(qwen.reasoning_effort, "none");

  const gptOss = {};
  suppressThinking(gptOss, "groq", "OpenAI/GPT-OSS-20B");
  assert.equal(gptOss.reasoning_effort, "low");
});

test("groq models of an unknown family are left untouched rather than sent a guessed enum", async () => {
  const { suppressThinking } = await load();

  const body = { model: "llama-3.3-70b-versatile", messages: [] };
  suppressThinking(body, "groq", "llama-3.3-70b-versatile");

  assert.deepEqual(body, { model: "llama-3.3-70b-versatile", messages: [] });
});

test("groq tolerates a missing model without throwing", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "groq", undefined);

  assert.deepEqual(body, {});
});

test("gemini gets reasoning_effort minimal and nothing else", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "gemini", "gemini-3-flash-preview");

  assert.deepEqual(body, { reasoning_effort: "minimal" });
});

test("openrouter gets its native reasoning toggle and nothing else", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "openrouter", "qwen/qwen3-32b");

  assert.deepEqual(body, { reasoning: { enabled: false } });
});

test("local gets think false plus chat_template_kwargs", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "local", "qwen3-8b");

  assert.deepEqual(body, { think: false, chat_template_kwargs: { enable_thinking: false } });
});

test("lan gets the nested reasoning object plus chat_template_kwargs", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "lan", "qwen3-8b");

  assert.deepEqual(body, {
    reasoning: { effort: "none" },
    chat_template_kwargs: { enable_thinking: false },
  });
});

test("lan sends a family's suppress floor inside the reasoning object, not a flat effort", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "lan", "gpt-oss-20b-mxfp4");

  assert.deepEqual(body, {
    reasoning: { effort: "low" },
    chat_template_kwargs: { enable_thinking: false },
  });
  assert.ok(!("reasoning_effort" in body), "flat reasoning_effort trips vLLM on lan (#1611)");
});

test("lan glm-5.3 floors at low: the family cannot disable reasoning", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "lan", "glm-5.3-flash");

  assert.deepEqual(body, {
    reasoning: { effort: "low" },
    chat_template_kwargs: { enable_thinking: false },
  });
});

test("unlisted providers keep the legacy reasoning_effort none plus chat_template_kwargs", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "openai", "gpt-5.2");

  assert.deepEqual(body, {
    reasoning_effort: "none",
    chat_template_kwargs: { enable_thinking: false },
  });
});

test("generic-dialect providers send gpt-oss the low floor, not the rejected none", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "tinfoil", "gpt-oss-120b");

  assert.deepEqual(body, {
    reasoning_effort: "low",
    chat_template_kwargs: { enable_thinking: false },
  });
});

test("the gpt-oss floor covers the whole family case-insensitively", async () => {
  const { suppressThinking } = await load();

  const safeguard = {};
  suppressThinking(safeguard, "tinfoil", "gpt-oss-safeguard-120b");
  assert.equal(safeguard.reasoning_effort, "low");

  const mixedCase = {};
  suppressThinking(mixedCase, "openai", "GPT-OSS-20B");
  assert.equal(mixedCase.reasoning_effort, "low");
});

test("mistral gets reasoning_effort none and never chat_template_kwargs", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "mistral", "mistral-small-latest");

  assert.deepEqual(body, { reasoning_effort: "none" });
  assert.ok(!("chat_template_kwargs" in body), "Mistral rejects chat_template_kwargs with a 422");
});

test("mistral magistral models are left untouched because they reason natively", async () => {
  const { suppressThinking } = await load();

  const body = { model: "magistral-medium-latest", messages: [] };
  suppressThinking(body, "mistral", "Magistral-Medium-Latest");

  assert.deepEqual(body, { model: "magistral-medium-latest", messages: [] });
});

test("mistral tolerates a missing model without throwing", async () => {
  const { suppressThinking } = await load();

  const body = {};
  suppressThinking(body, "mistral", undefined);

  assert.deepEqual(body, { reasoning_effort: "none" });
});

test("detectEndpointDialect maps the mistral api base to max_tokens and temperature", async () => {
  const { detectEndpointDialect } = await load();

  assert.deepEqual(detectEndpointDialect("https://api.mistral.ai/v1"), {
    key: "mistral",
    tokenParam: "max_tokens",
    supportsTemperature: true,
  });
});

test("detectEndpointDialect matches mistral hosts regardless of scheme, case, port or path", async () => {
  const { detectEndpointDialect } = await load();

  assert.equal(detectEndpointDialect("api.mistral.ai/v1")?.key, "mistral");
  assert.equal(detectEndpointDialect("https://mistral.ai")?.key, "mistral");
  assert.equal(detectEndpointDialect("https://API.Mistral.AI/v1/")?.key, "mistral");
  assert.equal(detectEndpointDialect("https://api.mistral.ai:443/v1")?.key, "mistral");
  assert.equal(detectEndpointDialect("https://[email protected]/v1")?.key, "mistral");
  assert.equal(detectEndpointDialect("https://api.mistral.ai/v1/chat/completions")?.key, "mistral");
});

test("detectEndpointDialect rejects lookalike hosts", async () => {
  const { detectEndpointDialect } = await load();

  assert.equal(detectEndpointDialect("https://api.openai.com/v1"), null);
  assert.equal(detectEndpointDialect("https://notmistral.ai"), null);
  assert.equal(detectEndpointDialect("https://mistral.ai.evil.com"), null);
});

test("detectEndpointDialect returns null for unparseable or missing input", async () => {
  const { detectEndpointDialect } = await load();

  assert.equal(detectEndpointDialect("::::"), null);
  assert.equal(detectEndpointDialect(""), null);
  assert.equal(detectEndpointDialect(undefined), null);
  assert.equal(detectEndpointDialect(null), null);
});

test("deepseek hosts get the native thinking switch, never reasoning_effort (#1260)", async () => {
  const { suppressThinking, detectEndpointDialect } = await load();

  const dialect = detectEndpointDialect("https://api.deepseek.com/v1");
  assert.deepEqual(dialect, { key: "deepseek", tokenParam: "max_tokens", supportsTemperature: true });

  const body = {};
  suppressThinking(body, "deepseek", "deepseek-chat");
  assert.deepEqual(body, { thinking: { type: "disabled" } });
});

test("cerebras hosts are strict like groq: family effort only, no chat_template_kwargs (#831)", async () => {
  const { suppressThinking, detectEndpointDialect } = await load();

  const dialect = detectEndpointDialect("https://api.cerebras.ai/v1");
  assert.equal(dialect?.key, "cerebras");

  const gptOss = {};
  suppressThinking(gptOss, "cerebras", "gpt-oss-120b");
  assert.deepEqual(gptOss, { reasoning_effort: "low" });

  const unknown = {};
  suppressThinking(unknown, "cerebras", "llama-4-maverick");
  assert.deepEqual(unknown, {});
});