import { describe, expect, it } from "vitest";
import { stripReasoningTagsFromText } from "./reasoning-tags.js";
describe("stripReasoningTagsFromText", () => {
describe("basic functionality", () => {
it("returns text unchanged when no reasoning tags present", () => {
const input = "Hello, this is a normal message.";
expect(stripReasoningTagsFromText(input)).toBe(input);
});
it("strips reasoning-tag variants", () => {
const cases = [
{
name: "strips proper think tags",
input: "Hello internal reasoning world!",
expected: "Hello world!",
},
{
name: "strips thinking tags",
input: "Before some thought after",
expected: "Before after",
},
{ name: "strips thought tags", input: "A hmm B", expected: "A B" },
{
name: "strips antthinking tags",
input: "X internal Y",
expected: "X Y",
},
] as const;
for (const { name, input, expected } of cases) {
expect(stripReasoningTagsFromText(input), name).toBe(expected);
}
});
it("strips multiple reasoning blocks", () => {
const input = "firstAsecondB";
expect(stripReasoningTagsFromText(input)).toBe("AB");
});
});
describe("code block preservation (issue #3952)", () => {
it("preserves tags inside code examples", () => {
const cases = [
"Use the tag like this:\n```\nreasoning\n```\nThat's it!",
"The `` tag is used for reasoning. Don't forget the closing `` tag.",
"Example:\n```xml\n\n nested\n\n```\nDone!",
"Use `` to open and `` to close.",
"Example:\n```\nreasoning\n```",
"Use `` for final answers in code: ```\n42\n```",
"First `` then ```\nblock\n``` then ``",
] as const;
for (const input of cases) {
expect(stripReasoningTagsFromText(input)).toBe(input);
}
});
it("handles mixed code-tag and real-tag content", () => {
const cases = [
{
input: "hiddenVisible text with `` example.",
expected: "Visible text with `` example.",
},
{
input: "```\ncode\n```\nreal hiddenvisible",
expected: "```\ncode\n```\nvisible",
},
] as const;
for (const { input, expected } of cases) {
expect(stripReasoningTagsFromText(input)).toBe(expected);
}
});
});
describe("edge cases", () => {
it("handles malformed tags and null-ish inputs", () => {
const cases = [
{
input: "Here is how to use ",
expected: "You can start with content< /think > B",
expected: "A B",
},
{
input: "",
expected: "",
},
{
input: null as unknown as string,
expected: null,
},
] as const;
for (const { input, expected } of cases) {
expect(stripReasoningTagsFromText(input)).toBe(expected);
}
});
it("handles fenced and inline code edge behavior", () => {
const cases = [
{
input: "Example:\n~~~\nreasoning\n~~~\nDone!",
expected: "Example:\n~~~\nreasoning\n~~~\nDone!",
},
{
input: "Example:\n~~~js\ncode\n~~~",
expected: "Example:\n~~~js\ncode\n~~~",
},
{
input: "Use ``code`` with hidden text",
expected: "Use ``code`` with text",
},
{
input: "Before\n```\ncode\n```\nAfter with hidden",
expected: "Before\n```\ncode\n```\nAfter with",
},
{
input: "```\nnot protected\n~~~\ntext",
expected: "```\nnot protected\n~~~\ntext",
},
{
input: "Start `unclosed hidden end",
expected: "Start `unclosed end",
},
] as const;
for (const { input, expected } of cases) {
expect(stripReasoningTagsFromText(input)).toBe(expected);
}
});
it("handles nested and final tag behavior", () => {
const cases = [
{
input: "outer inner still outervisible",
expected: "still outervisible",
},
{
input: "A1B2C",
expected: "A1B2C",
},
{
input: "`` in code, visible outside",
expected: "`` in code, visible outside",
},
] as const;
for (const { input, expected } of cases) {
expect(stripReasoningTagsFromText(input)).toBe(expected);
}
});
it("handles unicode, attributes, and case-insensitive tag names", () => {
const cases = [
{
input: "你好 思考 🤔 世界",
expected: "你好 世界",
},
{
input: "A hidden B",
expected: "A B",
},
{
input: "A hidden also hidden B",
expected: "A B",
},
] as const;
for (const { input, expected } of cases) {
expect(stripReasoningTagsFromText(input)).toBe(expected);
}
});
it("handles long content and pathological backtick patterns efficiently", () => {
const longContent = "x".repeat(10000);
expect(stripReasoningTagsFromText(`${longContent}visible`)).toBe("visible");
const pathological = "`".repeat(100) + "test" + "`".repeat(100);
const start = Date.now();
stripReasoningTagsFromText(pathological);
const elapsed = Date.now() - start;
expect(elapsed).toBeLessThan(1000);
});
});
describe("strict vs preserve mode", () => {
it("applies strict and preserve modes to unclosed tags", () => {
const input = "Before unclosed content after";
const cases = [
{ mode: "strict" as const, expected: "Before" },
{ mode: "preserve" as const, expected: "Before unclosed content after" },
];
for (const { mode, expected } of cases) {
expect(stripReasoningTagsFromText(input, { mode })).toBe(expected);
}
});
});
describe("trim options", () => {
it("applies configured trim strategies", () => {
const cases = [
{
input: " x result y ",
expected: "result",
opts: undefined,
},
{
input: " x result ",
expected: " result ",
opts: { trim: "none" as const },
},
{
input: " x result ",
expected: "result ",
opts: { trim: "start" as const },
},
] as const;
for (const testCase of cases) {
expect(stripReasoningTagsFromText(testCase.input, testCase.opts)).toBe(testCase.expected);
}
});
});
});