fix: parse Gemma 4 <thought> reasoning tags alongside <think>

Gemma 4 streams reasoning inside <thought>...</thought> instead of
<think>...</think>.  Without this the content leaks into chat text and
the agent triggers a retry on the first turn.

- TagMatcher: support multiple tag names - string[], track activeTagName so
    <think> is never closed by </thought> (and vice-versa).
- base-openai-compatible-provider and openai handler: match both tags.
- Tests: <thought> parsing, cross-tag isolation, and invariants.

Author: Sagid Magomedov

src/api/providers/__tests__/base-openai-compatible-provider.spec.ts

@@ -95,6 +95,75 @@ describe("BaseOpenAiCompatibleProvider", () => {
 			])
 		})
 
+		it("should handle reasoning tags (<thought>) from stream", async () => {
+			mockCreate.mockImplementationOnce(() => {
+				return {
+					[Symbol.asyncIterator]: () => ({
+						next: vi
+							.fn()
+							.mockResolvedValueOnce({
+								done: false,
+								value: { choices: [{ delta: { content: "<thought>Deep thought" } }] },
+							})
+							.mockResolvedValueOnce({
+								done: false,
+								value: { choices: [{ delta: { content: " here</thought>" } }] },
+							})
+							.mockResolvedValueOnce({
+								done: false,
+								value: { choices: [{ delta: { content: "Result: 42" } }] },
+							})
+							.mockResolvedValueOnce({ done: true }),
+					}),
+				}
+			})
+			const stream = handler.createMessage("system prompt", [])
+			const chunks = []
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+			expect(chunks).toEqual([
+				{ type: "reasoning", text: "Deep thought" },
+				{ type: "reasoning", text: " here" },
+				{ type: "text", text: "Result: 42" },
+			])
+		})
+
+		it("should not close <think> tag with </thought> tag", async () => {
+			mockCreate.mockImplementationOnce(() => {
+				return {
+					[Symbol.asyncIterator]: () => ({
+						next: vi
+							.fn()
+							.mockResolvedValueOnce({
+								done: false,
+								value: { choices: [{ delta: { content: "<think>Thinking" } }] },
+							})
+							.mockResolvedValueOnce({
+								done: false,
+								value: { choices: [{ delta: { content: " but closing with wrong tag</thought>" } }] },
+							})
+							.mockResolvedValueOnce({
+								done: false,
+								value: { choices: [{ delta: { content: " still thinking" } }] },
+							})
+							.mockResolvedValueOnce({ done: true }),
+					}),
+				}
+			})
+			const stream = handler.createMessage("system prompt", [])
+			const chunks = []
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+			// The </thought> tag should be treated as text since it doesn't match the active <think> tag
+			expect(chunks).toEqual([
+				{ type: "reasoning", text: "Thinking" },
+				{ type: "reasoning", text: " but closing with wrong tag</thought>" },
+				{ type: "reasoning", text: " still thinking" },
+			])
+		})
+
 		it("should handle complete <think> tag in a single chunk", async () => {
 			mockCreate.mockImplementationOnce(() => {
 				return {

src/api/providers/base-openai-compatible-provider.ts

@@ -118,7 +118,7 @@ export abstract class BaseOpenAiCompatibleProvider<ModelName extends string>
 		const stream = await this.createStream(systemPrompt, messages, metadata)
 
 		const matcher = new TagMatcher(
-			"think",
+			["think", "thought"],
 			(chunk) =>
 				({
 					type: chunk.matched ? "reasoning" : "text",

src/api/providers/openai.ts

@@ -184,7 +184,7 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 			}
 
 			const matcher = new TagMatcher(
-				"think",
+				["think", "thought"],
 				(chunk) =>
 					({
 						type: chunk.matched ? "reasoning" : "text",

src/utils/tag-matcher.ts

@@ -17,11 +17,17 @@ export class TagMatcher<Result = TagMatcherResult> {
 	state: "TEXT" | "TAG_OPEN" | "TAG_CLOSE" = "TEXT"
 	depth = 0
 	pointer = 0
+	private readonly tagNames: string[]
+	private activeTagName?: string
+	private candidates: { name: string; index: number }[] = []
+
 	constructor(
-		readonly tagName: string,
+		tagName: string | string[],
 		readonly transform?: (chunks: TagMatcherResult) => Result,
 		readonly position = 0,
-	) {}
+	) {
+		this.tagNames = Array.isArray(tagName) ? tagName : [tagName]
+	}
 	private collect() {
 		if (!this.cached.length) {
 			return
@@ -57,38 +63,56 @@ export class TagMatcher<Result = TagMatcherResult> {
 				if (char === "<" && (this.pointer <= this.position + 1 || this.matched)) {
 					this.state = "TAG_OPEN"
 					this.index = 0
+					this.candidates = this.tagNames.map((name) => ({ name, index: 0 }))
 				} else {
 					this.collect()
 				}
 			} else if (this.state === "TAG_OPEN") {
-				if (char === ">" && this.index === this.tagName.length) {
-					this.state = "TEXT"
-					if (!this.matched) {
-						this.cached = []
+				if (char === ">") {
+					const matched = this.candidates.find((c) => c.index === c.name.length)
+					if (matched) {
+						this.state = "TEXT"
+						this.activeTagName = matched.name
+						if (!this.matched) {
+							this.cached = []
+						}
+						this.depth++
+						this.matched = true
+						continue
 					}
-					this.depth++
-					this.matched = true
-				} else if (this.index === 0 && char === "/") {
+				} else if (this.candidates.every((c) => c.index === 0) && char === "/") {
 					this.state = "TAG_CLOSE"
-				} else if (char === " " && (this.index === 0 || this.index === this.tagName.length)) {
+					this.index = 0
 					continue
-				} else if (this.tagName[this.index] === char) {
-					this.index++
+				} else if (char === " ") {
+					const remaining = this.candidates.filter((c) => c.index === 0 || c.index === c.name.length)
+					if (remaining.length === this.candidates.length) {
+						continue
+					}
+					this.candidates = remaining
 				} else {
-					this.state = "TEXT"
-					this.collect()
+					this.candidates = this.candidates.filter((c) => c.name[c.index] === char)
+					for (const c of this.candidates) {
+						c.index++
+					}
+					if (this.candidates.length === 0) {
+						this.state = "TEXT"
+						this.collect()
+					}
 				}
 			} else if (this.state === "TAG_CLOSE") {
-				if (char === ">" && this.index === this.tagName.length) {
+				const tagName = this.activeTagName || this.tagNames[0]
+				if (char === ">" && this.index === tagName.length) {
 					this.state = "TEXT"
 					this.depth--
 					this.matched = this.depth > 0
 					if (!this.matched) {
+						this.activeTagName = undefined
 						this.cached = []
 					}
-				} else if (char === " " && (this.index === 0 || this.index === this.tagName.length)) {
+				} else if (char === " " && (this.index === 0 || this.index === tagName.length)) {
 					continue
-				} else if (this.tagName[this.index] === char) {
+				} else if (tagName[this.index] === char) {
 					this.index++
 				} else {
 					this.state = "TEXT"
@@ -102,6 +126,8 @@ export class TagMatcher<Result = TagMatcherResult> {
 			this._update(chunk)
 		}
 		this.collect()
+		this.candidates = []
+		this.activeTagName = undefined
 		return this.pop()
 	}
 	update(chunk: string) {