pi-free 2.1.0 → 2.1.1

package/providers/cline/cline-xml-bridge.ts

@@ -46,6 +46,73 @@ function normalizeApiModelId(modelId: string): string {
 		: modelId;
 }
 
+/**
+ * Some MiMo/Cline models emit XML tags wrapped in Unicode math-italic
+ * characters that spell out "anthml:" before the real tag name:
+ *   <𝑎𝑛𝑡𝑚𝑙:thinking>...</𝑎𝑛𝑡𝑚𝑙:thinking>
+ *   <𝑎𝑛𝑡𝑚𝑙:read_file>...</𝑎𝑛𝑡𝑚𝑙:read_file>
+ *
+ * This function strips the Unicode-decorated prefix so the rest of the
+ * parser sees standard ASCII XML tags.
+ */
+function normalizeDecoratedXmlTags(text: string): string {
+	const parts: string[] = [];
+	let cursor = 0;
+
+	while (cursor < text.length) {
+		const ltIndex = text.indexOf("<", cursor);
+		if (ltIndex === -1) {
+			parts.push(text.slice(cursor));
+			break;
+		}
+
+		parts.push(text.slice(cursor, ltIndex));
+		let contentStart = ltIndex + 1;
+		let prefix = "<";
+
+		// Handle closing tags: </𝑎𝑛𝑡𝑚𝑙:thinking> → </thinking>
+		if (contentStart < text.length && text[contentStart] === "/") {
+			prefix = "</";
+			contentStart += 1;
+		}
+
+		const gtIndex = text.indexOf(">", contentStart);
+		const colonIndex = text.indexOf(":", contentStart);
+		const spaceIndex = text.indexOf(" ", contentStart);
+		if (
+			colonIndex === -1 ||
+			colonIndex === contentStart ||
+			(gtIndex !== -1 && colonIndex > gtIndex) ||
+			(spaceIndex !== -1 && spaceIndex < colonIndex)
+		) {
+			parts.push(prefix);
+			cursor = contentStart;
+			continue;
+		}
+
+		// Strip non-ASCII bytes between prefix and : to undo Unicode-decorated
+		// prefixes like <𝑎𝑛𝑡𝑚𝑙:thinking> → <thinking>.
+		let hasNonAscii = false;
+		for (let i = contentStart; i < colonIndex; i++) {
+			if (text.charCodeAt(i) > 127) {
+				hasNonAscii = true;
+				break;
+			}
+		}
+
+		if (hasNonAscii) {
+			parts.push(prefix);
+			cursor = colonIndex + 1;
+		} else {
+			// No decorated prefix - emit < and re-include everything after it
+			parts.push("<");
+			cursor = ltIndex + 1;
+		}
+	}
+
+	return parts.join("");
+}
+
 function xmlEscape(value: unknown): string {
 	return String(value)
 		.replaceAll("&", "&amp;")
@@ -291,6 +358,111 @@ function executeCommandBridge(tool?: Tool): ToolBridge {
 	};
 }
 
+type HeredocWriteCommand = {
+	path: string;
+	content: string;
+};
+
+function shellSplitLine(line: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let quote: '"' | "'" | undefined;
+
+	for (let i = 0; i < line.length; i++) {
+		const char = line[i];
+		if (quote) {
+			if (char === quote) {
+				quote = undefined;
+			} else {
+				current += char;
+			}
+			continue;
+		}
+		if (char === '"' || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === " " || char === "\t") {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += char;
+	}
+
+	if (current) tokens.push(current);
+	return tokens;
+}
+
+function parseCatHeredocWriteCommand(
+	command: string,
+): HeredocWriteCommand | undefined {
+	const normalized = command.replaceAll("\r\n", "\n").trim();
+	const lines = normalized.split("\n");
+	if (lines.length < 3) return undefined;
+
+	const tokens = shellSplitLine(lines[0].trim());
+	if (tokens[0] !== "cat") return undefined;
+	const redirectIndex = tokens.indexOf(">");
+	if (redirectIndex === -1) return undefined;
+	const path = tokens[redirectIndex + 1];
+	if (!path) return undefined;
+
+	let delimiter = "";
+	for (let i = redirectIndex + 2; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "<<") {
+			delimiter = tokens[i + 1] ?? "";
+			break;
+		}
+		if (token.startsWith("<<")) {
+			delimiter = token.slice(2);
+			break;
+		}
+	}
+	if (!delimiter) return undefined;
+
+	let delimiterLine = -1;
+	for (let i = 1; i < lines.length; i++) {
+		if (lines[i].trim() === delimiter) {
+			delimiterLine = i;
+			break;
+		}
+	}
+	if (delimiterLine === -1) return undefined;
+
+	const trailing = lines
+		.slice(delimiterLine + 1)
+		.join("\n")
+		.trim();
+	if (trailing) {
+		const trailingLines = trailing.split("\n").filter((line) => line.trim());
+		if (trailingLines.length !== 1) return undefined;
+		const trailingTokens = shellSplitLine(trailingLines[0].trim());
+		if (trailingTokens.length !== 2 || trailingTokens[0] !== "cat") {
+			return undefined;
+		}
+		if (trailingTokens[1] !== path) return undefined;
+	}
+
+	return {
+		path,
+		content: lines.slice(1, delimiterLine).join("\n"),
+	};
+}
+
+function getWriteRuntimeToolName(
+	tools: Tool[] | undefined,
+): string | undefined {
+	if ((tools ?? []).some((tool) => tool.name === "write_to_file")) {
+		return "write_to_file";
+	}
+	if ((tools ?? []).some((tool) => tool.name === "write")) return "write";
+	return undefined;
+}
+
 function listFilesBridge(): ToolBridge {
 	return {
 		remoteName: "list_files",
@@ -558,54 +730,98 @@ function pushTextFragment(textParts: string[], fragment: string): void {
 	textParts.push(trimmed);
 }
 
+type HiddenThoughtTag = {
+	open: string;
+	closes: string[];
+};
+
+const HIDDEN_THOUGHT_TAGS: HiddenThoughtTag[] = [
+	{ open: "<thinking>", closes: ["</thinking>"] },
+	// Some DeepSeek/Cline variants open with <think> but close with </thinking>.
+	{ open: "<think>", closes: ["</think>", "</thinking>"] },
+	// Compaction/summary artifacts can leak into Cline content as </summary>.
+	{ open: "<summary>", closes: ["</summary>"] },
+	// Cline may emit persistent issue-checking as hidden deliberation.
+	{
+		open: "<persistent_issue_checking>",
+		closes: ["</persistent_issue_checking>"],
+	},
+];
+
+const HIDDEN_THOUGHT_CLOSE_TAGS = Array.from(
+	new Set(HIDDEN_THOUGHT_TAGS.flatMap((tag) => tag.closes)),
+);
+
+function findNextHiddenOpenTag(
+	text: string,
+	from: number,
+): { index: number; tag: HiddenThoughtTag } | null {
+	let best: { index: number; tag: HiddenThoughtTag } | null = null;
+	for (const tag of HIDDEN_THOUGHT_TAGS) {
+		const index = text.indexOf(tag.open, from);
+		if (index === -1) continue;
+		if (!best || index < best.index) best = { index, tag };
+	}
+	return best;
+}
+
+function findNextCloseTag(
+	text: string,
+	from: number,
+	closeTags: string[],
+): { index: number; tag: string } | null {
+	let best: { index: number; tag: string } | null = null;
+	for (const tag of closeTags) {
+		const index = text.indexOf(tag, from);
+		if (index === -1) continue;
+		if (!best || index < best.index) best = { index, tag };
+	}
+	return best;
+}
+
 function extractThinkingXml(text: string): {
 	text: string;
 	thinking: string[];
 } {
 	const thinking: string[] = [];
 	const parts: string[] = [];
-	const openTags = ["<thinking>", "<think>"];
-	const closeTag = "</thinking>";
 	let cursor = 0;
 
-	function findNextOpenTag(from: number): { index: number; tag: string } | null {
-		let best: { index: number; tag: string } | null = null;
-		for (const tag of openTags) {
-			const index = text.indexOf(tag, from);
-			if (index === -1) continue;
-			if (!best || index < best.index) best = { index, tag };
-		}
-		return best;
-	}
-
 	while (cursor < text.length) {
-		const nextOpen = findNextOpenTag(cursor);
+		const nextOpen = findNextHiddenOpenTag(text, cursor);
 		const openStart = nextOpen?.index ?? -1;
-		const closeStart = text.indexOf(closeTag, cursor);
+		const nextClose = findNextCloseTag(text, cursor, HIDDEN_THOUGHT_CLOSE_TAGS);
+		const closeStart = nextClose?.index ?? -1;
 
-		if (closeStart !== -1 && (openStart === -1 || closeStart < openStart)) {
+		if (nextClose && (openStart === -1 || closeStart < openStart)) {
 			const danglingThinking = decodeXmlEntities(
 				text.slice(cursor, closeStart).trim(),
 			);
 			if (danglingThinking) thinking.push(danglingThinking);
-			cursor = closeStart + closeTag.length;
+			cursor = closeStart + nextClose.tag.length;
 			continue;
 		}
 
 		if (openStart === -1 || !nextOpen) break;
 		parts.push(text.slice(cursor, openStart));
-		const valueStart = openStart + nextOpen.tag.length;
-		const valueEnd = text.indexOf(closeTag, valueStart);
-		if (valueEnd === -1) {
+		const valueStart = openStart + nextOpen.tag.open.length;
+		const nextValueClose = findNextCloseTag(
+			text,
+			valueStart,
+			nextOpen.tag.closes,
+		);
+		if (!nextValueClose) {
 			const value = decodeXmlEntities(text.slice(valueStart).trim());
 			if (value) thinking.push(value);
 			cursor = text.length;
 			break;
 		}
 
-		const value = decodeXmlEntities(text.slice(valueStart, valueEnd).trim());
+		const value = decodeXmlEntities(
+			text.slice(valueStart, nextValueClose.index).trim(),
+		);
 		if (value) thinking.push(value);
-		cursor = valueEnd + closeTag.length;
+		cursor = nextValueClose.index + nextValueClose.tag.length;
 	}
 
 	if (cursor === 0) {
@@ -661,9 +877,17 @@ function parseToolArguments(block: string): Record<string, unknown> {
 				: block.indexOf(close, openEnd + 1);
 		if (closeStart === -1 || closeStart < openEnd) break;
 		const raw = decodeXmlEntities(block.slice(openEnd + 1, closeStart).trim());
-		try {
-			args[tag] = JSON.parse(raw);
-		} catch {
+		// `content` and `diff` are explicitly string parameters (file bodies,
+		// SEARCH/REPLACE diffs). Parsing them as JSON corrupts JSON file content
+		// into "[object Object]".
+		const shouldParseJson = tag !== "content" && tag !== "diff";
+		if (shouldParseJson) {
+			try {
+				args[tag] = JSON.parse(raw);
+			} catch {
+				args[tag] = raw;
+			}
+		} else {
 			args[tag] = raw;
 		}
 		cursor = closeStart + close.length;
@@ -671,20 +895,70 @@ function parseToolArguments(block: string): Record<string, unknown> {
 	return args;
 }
 
+type ParsedToolCalls = {
+	text: string;
+	toolCalls: Array<{ name: string; arguments: Record<string, unknown> }>;
+};
+
+/**
+ * Some MiMo/Cline models emit Pi SDK `<function=name>` tool-call syntax
+ * instead of Cline XML `<toolName>` syntax:
+ *
+ *   <function=read_file>
+ *   <param name="path">README.md</param>
+ *   </function>
+ *
+ * Parse these directly to Pi tool calls without going through Cline XML.
+ */
+function extractFunctionTagToolCalls(
+	text: string,
+	bridgeByRemoteName: Map<string, ToolBridge>,
+): { text: string; toolCalls: ParsedToolCalls["toolCalls"] } {
+	const FUNCTION_TAG_RE = /<function=([a-zA-Z0-9_-]+)>([\s\S]*?)<\/function>/g;
+	const toolCalls: ParsedToolCalls["toolCalls"] = [];
+	const parts: string[] = [];
+	let cursor = 0;
+	let match: RegExpExecArray | null;
+
+	while ((match = FUNCTION_TAG_RE.exec(text)) !== null) {
+		const [fullMatch, toolName, body] = match;
+		pushTextFragment(parts, text.slice(cursor, match.index));
+
+		// Parse <param name="x">val</param> directly to arguments
+		const args: Record<string, unknown> = {};
+		const PARAM_RE = /<param\s+name="([^"]*)">([\s\S]*?)<\/param>/g;
+		let paramMatch: RegExpExecArray | null;
+		while ((paramMatch = PARAM_RE.exec(body)) !== null) {
+			args[paramMatch[1]] = paramMatch[2];
+		}
+
+		const bridge = bridgeByRemoteName.get(toolName);
+		toolCalls.push({
+			name: bridge?.runtimeName ?? toolName,
+			arguments: bridge?.toRuntimeArgs(args) ?? args,
+		});
+
+		cursor = match.index + fullMatch.length;
+	}
+
+	pushTextFragment(parts, text.slice(cursor));
+	return { text: parts.join("\n\n").trim(), toolCalls };
+}
+
 function parseXmlToolCalls(
 	rawText: string,
 	tools: Tool[] | undefined,
-): {
-	text: string;
-	toolCalls: Array<{ name: string; arguments: Record<string, unknown> }>;
-} {
+): ParsedToolCalls {
 	const bridgeByRemoteName = new Map(
 		getParseToolBridges(tools).map((bridge) => [bridge.remoteName, bridge]),
 	);
 	const toolNames = new Set(bridgeByRemoteName.keys());
-	const textWithoutThinking = extractThinkingXml(rawText).text;
+
+	// Extract <function=name> Pi SDK tool calls directly (no Cline XML intermediate)
+	const fnResult = extractFunctionTagToolCalls(rawText, bridgeByRemoteName);
+	const textWithoutThinking = extractThinkingXml(fnResult.text).text;
 	if (toolNames.size === 0) {
-		return { text: textWithoutThinking.trim(), toolCalls: [] };
+		return { text: textWithoutThinking.trim(), toolCalls: fnResult.toolCalls };
 	}
 
 	const sourceText = findNextToolStart(textWithoutThinking, toolNames, 0)
@@ -708,16 +982,125 @@ function parseXmlToolCalls(
 		const block = sourceText.slice(next.index + next.openTag.length, blockEnd);
 		const bridge = bridgeByRemoteName.get(next.name);
 		const remoteArgs = parseToolArguments(block);
-		toolCalls.push({
-			name: bridge?.runtimeName ?? next.name,
-			arguments: bridge?.toRuntimeArgs(remoteArgs) ?? remoteArgs,
-		});
+		const writeRuntimeName = getWriteRuntimeToolName(tools);
+		const heredocWrite =
+			next.name === "execute_command" && writeRuntimeName
+				? parseCatHeredocWriteCommand(stringArg(remoteArgs, "command"))
+				: undefined;
+		if (heredocWrite && writeRuntimeName) {
+			toolCalls.push({
+				name: writeRuntimeName,
+				arguments: { ...heredocWrite },
+			});
+		} else {
+			toolCalls.push({
+				name: bridge?.runtimeName ?? next.name,
+				arguments: bridge?.toRuntimeArgs(remoteArgs) ?? remoteArgs,
+			});
+		}
 		cursor =
 			closeStart === -1 ? sourceText.length : closeStart + closeTag.length;
 	}
 
 	pushTextFragment(textParts, sourceText.slice(cursor));
-	return { text: textParts.join("\n\n").trim(), toolCalls };
+	return { text: textParts.join("\n\n").trim(), toolCalls: [...fnResult.toolCalls, ...toolCalls] };
+}
+
+function parseReasoningHiddenToolCalls(
+	thinkingParts: string[],
+	tools: Tool[] | undefined,
+	depth = 3,
+): { thinking: string[]; toolCalls: ParsedToolCalls["toolCalls"] } {
+	const thinking: string[] = [];
+	const toolCalls: ParsedToolCalls["toolCalls"] = [];
+	for (const part of thinkingParts) {
+		const trimmed = part.trim();
+		if (!trimmed) continue;
+		if (depth <= 0) {
+			thinking.push(trimmed);
+			continue;
+		}
+		const extracted = extractThinkingXml(trimmed);
+		const nested = parseReasoningHiddenToolCalls(
+			extracted.thinking,
+			tools,
+			depth - 1,
+		);
+		const parsed = parseXmlToolCalls(extracted.text, tools);
+		toolCalls.push(...parsed.toolCalls, ...nested.toolCalls);
+		if (parsed.text) thinking.push(parsed.text);
+		thinking.push(...nested.thinking);
+		if (
+			!parsed.text &&
+			parsed.toolCalls.length === 0 &&
+			nested.toolCalls.length === 0 &&
+			nested.thinking.length === 0
+		) {
+			thinking.push(trimmed);
+		}
+	}
+	return { thinking, toolCalls };
+}
+
+function parseReasoningToolCalls(
+	reasoning: string,
+	tools: Tool[] | undefined,
+): { thinking: string[]; toolCalls: ParsedToolCalls["toolCalls"] } {
+	if (!reasoning.trim()) return { thinking: [], toolCalls: [] };
+
+	const extracted = extractThinkingXml(reasoning);
+	const hiddenParsed = parseReasoningHiddenToolCalls(extracted.thinking, tools);
+	const parsed = parseXmlToolCalls(extracted.text, tools);
+	const thinking = [...hiddenParsed.thinking];
+	if (parsed.toolCalls.length > 0 && parsed.text) {
+		thinking.push(parsed.text);
+	} else if (
+		parsed.toolCalls.length === 0 &&
+		hiddenParsed.thinking.length === 0 &&
+		extracted.thinking.length === 0
+	) {
+		thinking.push(reasoning.trim());
+	}
+
+	return {
+		thinking,
+		toolCalls: [...parsed.toolCalls, ...hiddenParsed.toolCalls],
+	};
+}
+
+const INTERNAL_ONLY_RESPONSE =
+	"Cline returned internal reasoning only and did not produce a user-visible response. Please retry or ask it to continue.";
+
+function prepareClineXmlOutput(
+	parsedText: string,
+	contentThinking: string[],
+	reasoningThinking: string[],
+	toolCalls: ParsedToolCalls["toolCalls"],
+): {
+	visibleText: string;
+	thinkingText: string;
+	toolCalls: ParsedToolCalls["toolCalls"];
+} {
+	const thinkingParts = [...reasoningThinking, ...contentThinking].filter(
+		Boolean,
+	);
+	const thinkingText = thinkingParts.join("\n\n");
+	if (!parsedText && toolCalls.length === 0 && thinkingText) {
+		// Never return a blank stop, but also do not surface hidden reasoning as
+		// user-visible answer text. If Cline sends only hidden/reasoning content,
+		// show a stable visible fallback and keep the raw content in thinking.
+		return {
+			visibleText: INTERNAL_ONLY_RESPONSE,
+			thinkingText,
+			toolCalls,
+		};
+	}
+
+	return {
+		visibleText: parsedText,
+		thinkingText,
+		toolCalls,
+	};
 }
 
 function usageFromChunkUsage(usage: ClineXmlChunk["usage"] | undefined): Usage {
@@ -754,6 +1137,121 @@ async function* parseSse(response: Response): AsyncGenerator<ClineXmlChunk> {
 	}
 }
 
+type ClineXmlResponseData = {
+	rawText: string;
+	thinking: string;
+	finishReason: string | null | undefined;
+	usage: ClineXmlChunk["usage"] | undefined;
+};
+
+function isRetryableClineReasoningStreamError(error: unknown): boolean {
+	if (!(error instanceof Error)) return false;
+	const message = error.message.toLowerCase();
+	return message.includes("stream error occurred");
+}
+
+async function readClineXmlResponse(
+	response: Response,
+): Promise<ClineXmlResponseData> {
+	let rawText = "";
+	let thinking = "";
+	let finishReason: string | null | undefined;
+	let usage: ClineXmlChunk["usage"] | undefined;
+
+	for await (const chunk of parseSse(response)) {
+		if (chunk.error) {
+			throw new Error(
+				`${chunk.error.code ?? "cline_error"}: ${chunk.error.message ?? "Unknown Cline error"}`,
+			);
+		}
+		if (chunk.usage) usage = chunk.usage;
+		const choice = chunk.choices?.[0];
+		if (!choice) continue;
+		if (choice.error) {
+			throw new Error(
+				`${choice.error.code ?? "cline_error"}: ${choice.error.message ?? "Unknown Cline error"}`,
+			);
+		}
+		if (choice.finish_reason) finishReason = choice.finish_reason;
+		rawText += choice.delta?.content ?? "";
+		thinking += choice.delta?.reasoning ?? "";
+	}
+
+	if (!rawText.trim() && !thinking.trim()) {
+		throw new Error("Cline returned empty response");
+	}
+
+	// Some MiMo/Cline models wrap XML tags in Unicode math-italic characters
+	// forming "anthml:" prefixes (e.g. <𝑎𝑛𝑡𝑚𝑙:thinking>, <𝑎𝑛𝑡𝑚𝑙:read_file>).
+	// Strip these so the rest of the parser sees standard ASCII XML tags.
+	return {
+		rawText: normalizeDecoratedXmlTags(rawText),
+		thinking: normalizeDecoratedXmlTags(thinking),
+		finishReason,
+		usage,
+	};
+}
+
+async function fetchClineXmlResponse(
+	model: Model<string>,
+	context: Context,
+	options: SimpleStreamOptions,
+	headers: Record<string, string>,
+	includeReasoning: boolean,
+): Promise<ClineXmlResponseData> {
+	const response = await fetch(`${BASE_URL_CLINE}/chat/completions`, {
+		method: "POST",
+		headers: {
+			...headers,
+			Authorization: `Bearer ${options.apiKey}`,
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify({
+			model: normalizeApiModelId(model.id),
+			temperature: 0,
+			messages: buildClineXmlMessages(context),
+			stream: true,
+			stream_options: { include_usage: true },
+			...(includeReasoning ? { include_reasoning: true } : {}),
+		}),
+		signal: options.signal,
+	});
+	await options.onResponse?.(
+		{
+			status: response.status,
+			headers: Object.fromEntries(response.headers.entries()),
+		},
+		model,
+	);
+
+	if (!response.ok) {
+		throw new Error(
+			`Cline API error ${response.status}: ${await response.text()}`,
+		);
+	}
+
+	return readClineXmlResponse(response);
+}
+
+async function fetchClineXmlResponseWithReasoningFallback(
+	model: Model<string>,
+	context: Context,
+	options: SimpleStreamOptions,
+	headers: Record<string, string>,
+): Promise<ClineXmlResponseData> {
+	try {
+		return await fetchClineXmlResponse(model, context, options, headers, true);
+	} catch (error) {
+		if (
+			options.signal?.aborted ||
+			!isRetryableClineReasoningStreamError(error)
+		) {
+			throw error;
+		}
+		return fetchClineXmlResponse(model, context, options, headers, false);
+	}
+}
+
 function createAssistant(model: Model<string>): AssistantMessage {
 	return {
 		role: "assistant",
@@ -871,78 +1369,71 @@ export function streamClineXml(
 				throw new Error("No Cline access token found. Run /login cline first.");
 			}
 
-			const response = await fetch(`${BASE_URL_CLINE}/chat/completions`, {
-				method: "POST",
-				headers: {
-					...headers,
-					Authorization: `Bearer ${options.apiKey}`,
-					"Content-Type": "application/json",
-				},
-				body: JSON.stringify({
-					model: normalizeApiModelId(model.id),
-					temperature: 0,
-					messages: buildClineXmlMessages(context),
-					stream: true,
-					stream_options: { include_usage: true },
-					include_reasoning: true,
-				}),
-				signal: options.signal,
-			});
-			await options.onResponse?.(
-				{
-					status: response.status,
-					headers: Object.fromEntries(response.headers.entries()),
-				},
-				model,
-			);
-
-			if (!response.ok) {
-				throw new Error(
-					`Cline API error ${response.status}: ${await response.text()}`,
-				);
-			}
-
-			let rawText = "";
-			let thinking = "";
+			let output: ReturnType<typeof prepareClineXmlOutput>;
+			let rawText: string;
+			let thinking: string;
 			let finishReason: string | null | undefined;
 			let usage: ClineXmlChunk["usage"] | undefined;
+			let currentContext = context;
+
+			for (let attempt = 0; attempt < 2; attempt++) {
+				const data = await fetchClineXmlResponseWithReasoningFallback(
+					model,
+					currentContext,
+					options,
+					headers,
+				);
+				rawText = data.rawText;
+				thinking = data.thinking;
+				finishReason = data.finishReason;
+				usage = data.usage;
+
+				const extractedThinking = extractThinkingXml(rawText);
+				const parsedReasoning = parseReasoningToolCalls(
+					thinking,
+					currentContext.tools,
+				);
+				const parsed = parseXmlToolCalls(extractedThinking.text, currentContext.tools);
+				output = prepareClineXmlOutput(
+					parsed.text,
+					extractedThinking.thinking,
+					parsedReasoning.thinking,
+					[...parsed.toolCalls, ...parsedReasoning.toolCalls],
+				);
 
-			for await (const chunk of parseSse(response)) {
-				if (chunk.error) {
-					throw new Error(
-						`${chunk.error.code ?? "cline_error"}: ${chunk.error.message ?? "Unknown Cline error"}`,
-					);
+				// Reasoning-only response: MiMo stopped without producing visible
+				// text or tool calls. Auto-retry once with a "continue" nudge
+				// instead of showing a dead-end error to the user.
+				if (
+					output.visibleText === INTERNAL_ONLY_RESPONSE &&
+					attempt === 0
+				) {
+					currentContext = {
+						...context,
+						messages: [
+							...context.messages,
+							{
+								role: "user" as const,
+								content: [{ type: "text" as const, text: "Please continue." }],
+								timestamp: Date.now(),
+							},
+						],
+					};
+					continue;
 				}
-				if (chunk.usage) usage = chunk.usage;
-				const choice = chunk.choices?.[0];
-				if (!choice) continue;
-				if (choice.error) {
-					throw new Error(
-						`${choice.error.code ?? "cline_error"}: ${choice.error.message ?? "Unknown Cline error"}`,
-					);
-				}
-				if (choice.finish_reason) finishReason = choice.finish_reason;
-				rawText += choice.delta?.content ?? "";
-				thinking += choice.delta?.reasoning ?? "";
+				break;
 			}
 
-			assistant.usage = usageFromChunkUsage(usage);
-			const extractedThinking = extractThinkingXml(rawText);
-			pushThinking(
-				assistant,
-				[thinking.trim(), ...extractedThinking.thinking]
-					.filter(Boolean)
-					.join("\n\n"),
-				stream,
-			);
-			const parsed = parseXmlToolCalls(extractedThinking.text, context.tools);
-			pushText(assistant, parsed.text, stream);
-			for (const toolCall of parsed.toolCalls) {
+			assistant.usage = usageFromChunkUsage(usage!);
+			pushThinking(assistant, output!.thinkingText, stream);
+			pushText(assistant, output!.visibleText, stream);
+			const toolCalls = output!.toolCalls;
+			for (const toolCall of toolCalls) {
 				pushToolCall(assistant, toolCall, stream);
 			}
 
 			assistant.stopReason =
-				parsed.toolCalls.length > 0
+				toolCalls.length > 0
 					? "toolUse"
 					: finishReason === "length"
 						? "length"
@@ -969,6 +1460,12 @@ export function streamClineXml(
 
 export const __test__ = {
 	buildClineXmlMessages,
+	extractFunctionTagToolCalls,
+	isRetryableClineReasoningStreamError,
+	normalizeDecoratedXmlTags,
+	parseReasoningHiddenToolCalls,
+	parseReasoningToolCalls,
 	parseXmlToolCalls,
+	prepareClineXmlOutput,
 	serializeXmlToolCall,
 };