import { parseToolCallsFromContent } from "./tool-call-parser"; const stripToolCallXmlBlocks = (text: string): string => {  if (!text) return "";  let cleaned = text;  cleaned = cleaned.replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, "");  cleaned = cleaned.replace(/<?use_mcp[\s_]*tool>[\s\S]*?<\/use_mcp[\s_]*tool>/gi, "");  cleaned = cleaned.replace(/\n{3,}/g, "\n\n");  return cleaned.trim();}; const collapseRepeatedVisibleContent = (text: string): string => {  const trimmed = text.trim();  if (trimmed.length < 80) return text;  for (let separatorLength = 0; separatorLength <= 4; separatorLength += 1) {    const contentLength = trimmed.length - separatorLength;    if (contentLength <= 0 || contentLength % 2 !== 0) continue;    const midpoint = contentLength / 2;    const first = trimmed.slice(0, midpoint).trimEnd();    const second = trimmed.slice(midpoint + separatorLength).trimStart();    if (first.length >= 40 && first === second) return first;  }  return text;}; const extractThinkBlocks = (text: string): { cleaned: string; extracted: string[] } => {  if (!text) return { cleaned: "", extracted: [] };   const extracted: string[] = [];  const visibleParts: string[] = [];  let remaining = String(text);   const openPrefixes = ["<think", "<thinking", "<analysis"];  const closePrefixes = ["</think", "</thinking", "</analysis"];   const findNextTag = (lower: string): { kind: "open" | "close"; index: number } | null => {    let openIndex = -1;    for (const prefix of openPrefixes) {      const index = lower.indexOf(prefix);      if (index >= 0) openIndex = openIndex === -1 ? index : Math.min(openIndex, index);    }    let closeIndex = -1;    for (const prefix of closePrefixes) {      const index = lower.indexOf(prefix);      if (index >= 0) closeIndex = closeIndex === -1 ? index : Math.min(closeIndex, index);    }    if (openIndex === -1 && closeIndex === -1) return null;    if (openIndex !== -1 && (closeIndex === -1 || openIndex < closeIndex))      return { kind: "open", index: openIndex };    return { kind: "close", index: closeIndex };  };   const parseTag = (    input: string,    start: number  ): { name: "think" | "thinking" | "analysis"; end: number } | null => {    const closeIndex = input.indexOf(">", start);    if (closeIndex < 0) return null;    const tag = input.slice(start, closeIndex + 1);    const open = tag.match(/^<(think|thinking|analysis)(?:\s+[^>]*)?>$/i);    if (open)      return {        name: open[1]!.toLowerCase() as "think" | "thinking" | "analysis",        end: closeIndex + 1,      };    const close = tag.match(/^<\/(think|thinking|analysis)(?:\s+[^>]*)?>$/i);    if (close)      return {        name: close[1]!.toLowerCase() as "think" | "thinking" | "analysis",        end: closeIndex + 1,      };    return null;  };   while (remaining) {    const lower = remaining.toLowerCase();    const next = findNextTag(lower);    if (!next) {      visibleParts.push(remaining);      break;    }     if (next.kind === "open") {      if (next.index > 0) visibleParts.push(remaining.slice(0, next.index));       const openTag = parseTag(remaining, next.index);      if (!openTag) {        visibleParts.push(remaining.slice(0, next.index + 1));        remaining = remaining.slice(next.index + 1);        continue;      }       remaining = remaining.slice(openTag.end);      const lowerAfter = remaining.toLowerCase();      const closeStart = lowerAfter.indexOf(`</${openTag.name}`);      if (closeStart < 0) {        const value = remaining.trim();        if (value) extracted.push(value);        remaining = "";        break;      }       const inner = remaining.slice(0, closeStart);      const value = inner.trim();      if (value) extracted.push(value);       const closeTag = parseTag(remaining, closeStart);      if (!closeTag) {        remaining = remaining.slice(closeStart + 1);        continue;      }      remaining = remaining.slice(closeTag.end);      continue;    }     if (next.index > 0) {      const value = remaining.slice(0, next.index).trim();      if (value) extracted.push(value);    }    const closeTag = parseTag(remaining, next.index);    remaining = closeTag ? remaining.slice(closeTag.end) : remaining.slice(next.index + 1);  }   return { cleaned: visibleParts.join("").trim(), extracted };}; export const normalizeReasoningAndContentInMessage = (message: Record<string, unknown>): void => {  const contentRaw = typeof message["content"] === "string" ? String(message["content"]) : "";  const reasoningRaw =    typeof message["reasoning_content"] === "string" ? String(message["reasoning_content"]) : "";   const contentThink = extractThinkBlocks(contentRaw);  const reasoningThink = extractThinkBlocks(reasoningRaw);  const extracted = [...contentThink.extracted, ...reasoningThink.extracted].filter(Boolean);   const nextReasoning = [reasoningThink.cleaned, extracted.join("\n")]    .filter((v) => v.trim().length > 0)    .join("\n");  const nextContent = contentThink.cleaned;   if (nextContent !== contentRaw) message["content"] = nextContent;  if (nextReasoning !== reasoningRaw) message["reasoning_content"] = nextReasoning;   const strippedContent = stripToolCallXmlBlocks(    typeof message["content"] === "string" ? String(message["content"]) : ""  );  const strippedReasoning = stripToolCallXmlBlocks(    typeof message["reasoning_content"] === "string" ? String(message["reasoning_content"]) : ""  );  message["content"] = collapseRepeatedVisibleContent(strippedContent);  if (strippedReasoning) {    message["reasoning_content"] = strippedReasoning;  } else {    delete message["reasoning_content"];  }}; export const normalizeToolCallsInMessage = (message: Record<string, unknown>): boolean => {  const existing = message["tool_calls"];  const hasToolCalls = Array.isArray(existing) && existing.length > 0;  if (hasToolCalls) {    return false;  }  const content = typeof message["content"] === "string" ? String(message["content"]) : "";  const parsed = parseToolCallsFromContent(content);  if (parsed.length > 0) {    message["tool_calls"] = parsed;    return true;  }  return false;};