winter-super-cli 2026.5.32 → 2026.6.5

package/src/cli/slash-commands.js

@@ -1,14 +1,23 @@
 export const SLASH_COMMANDS = [
   { cmd: '/project', desc: 'Show/set current project' },
+  { cmd: '/index', desc: 'Index codebase for semantic search', usage: '/index [full]' },
+  { cmd: '/search', desc: 'Semantic codebase search', usage: '/search <query>' },
+  { cmd: '/search-def', desc: 'Find symbol/definition in codebase', usage: '/search-def <name>' },
+  { cmd: '/undo', desc: 'Undo last change from backup', usage: '/undo [file]' },
   { cmd: '/cd', desc: 'Change directory' },
   { cmd: '/pwd', desc: 'Show current directory' },
   { cmd: '/session', desc: 'Session management' },
   { cmd: '/sessions', desc: 'List all sessions' },
+  { cmd: '/history', desc: 'Browse recent chat and tool history', usage: '/history [count]' },
+  { cmd: '/new', desc: 'Start a new conversation' },
   { cmd: '/clear', desc: 'Clear screen' },
   { cmd: '/remember', desc: 'Store in memory', usage: '/remember <text>' },
   { cmd: '/memories', desc: 'Show stored memories' },
+  { cmd: '/memory-vault', desc: 'Show TokenJuice Obsidian memory vault', usage: '/memory-vault [list]' },
   { cmd: '/forget', desc: 'Clear memories', usage: '/forget [pattern]' },
   { cmd: '/compress', desc: 'Compress old conversation context' },
+  { cmd: '/context', desc: 'Inspect what Winter sends to the model', usage: '/context [task]' },
+  { cmd: '/scorecard', desc: 'Score Winter against Codebuff/Codex/Claude capability gates' },
   { cmd: '/plan', desc: 'Create/view plans' },
   { cmd: '/plans', desc: 'List active plans' },
   { cmd: '/tasks', desc: 'List tasks' },
@@ -16,13 +25,14 @@ export const SLASH_COMMANDS = [
   { cmd: '/agent', desc: 'Launch subagent', usage: '/agent <task>' },
   { cmd: '/auto', desc: 'Auto-heal with test/build loop', usage: '/auto [task]' },
   { cmd: '/debug', desc: 'Auto-debug errors with tool verification', usage: '/debug [error or task]' },
+  { cmd: '/doctor', desc: 'Diagnose provider/model/tool calling and context', usage: '/doctor [full|tools|context|scorecard]' },
   { cmd: '/tdd', desc: 'Alias for auto-healing loop', usage: '/tdd [task]' },
   { cmd: '/read', desc: 'Read file', usage: '/read <file>' },
   { cmd: '/write', desc: 'Write file', usage: '/write <file> <content>' },
   { cmd: '/glob', desc: 'Find files', usage: '/glob <pattern>' },
   { cmd: '/grep', desc: 'Search files', usage: '/grep <pattern>' },
   { cmd: '/bash', desc: 'Run command', usage: '/bash <command>' },
-  { cmd: '/image', desc: 'Analyze image/screenshot', usage: '/image <file> [question]' },
+  { cmd: '/image', desc: 'Analyze image/screenshot or clipboard image', usage: '/image [file] [question]' },
   { cmd: '/design', desc: 'Design commands', sub: ['search', 'add', 'list', 'preview'] },
   { cmd: '/designs', desc: 'List/search awesome-design-md systems', usage: '/designs [query]' },
   { cmd: '/skill', desc: 'Skills management', sub: ['list', 'enable', 'create'] },
@@ -38,12 +48,23 @@ export const SLASH_COMMANDS = [
   { cmd: '/codex', desc: 'Browse ~/.codex resources', usage: '/codex [skills|plugins|models|rules|memories]' },
   { cmd: '/claude', desc: 'Browse ~/.claude resources', usage: '/claude [skills|plugins|settings]' },
   { cmd: '/karpathy', desc: 'Browse karpathy-tools and guidelines' },
+  { cmd: '/page-agent', desc: 'Browse page-agent (GUI agent) resources' },
+  { cmd: '/pageagent', desc: 'Browse page-agent (GUI agent) resources' },
+  { cmd: '/ecc', desc: 'ECC resource browser', sub: ['info', 'browse', 'search', 'sync'] },
+  { cmd: '/composer', desc: 'Multi-file editing mode (like Cursor Composer)', usage: '/composer <task>' },
+  { cmd: '/complete', desc: 'Trigger inline code completion', usage: '/complete <file> [line] [col]' },
+  { cmd: '/browse', desc: 'Browse URL in Chrome via browser automation', usage: '/browse <url>' },
+  { cmd: '/ensemble', desc: 'Run all AI providers in parallel', usage: '/ensemble <prompt>' },
+  { cmd: '/vote', desc: 'Run multiple models and vote for best answer', usage: '/vote <prompt>' },
+  { cmd: '/orchestrate', desc: 'Full pipeline: classify → parallel → merge → review', usage: '/orchestrate <task>' },
   { cmd: '/agents', desc: 'Read ~/agents.md' },
   { cmd: '/resources', desc: 'Show bundled local resource manifest' },
   { cmd: '/provider', desc: 'Show/switch AI provider', usage: '/provider <custom|claude|ollama|openai|groq>' },
   { cmd: '/providers', desc: 'List all providers' },
   { cmd: '/models', desc: 'List configured/cached models' },
   { cmd: '/config', desc: 'Show configuration' },
+  { cmd: '/theme', desc: 'Set UI theme', usage: '/theme <dark|light>' },
+  { cmd: '/theme:toggle', desc: 'Toggle light/dark theme' },
   { cmd: '/model', desc: 'Show/set active provider model', usage: '/model <model-id>' },
   { cmd: '/help', desc: 'Show this help' },
   { cmd: '/?', desc: 'Show help' },

package/src/cli/snowflake-logo.js

@@ -1,4 +1,4 @@
-import { renderBox, terminalWidth } from './terminal-ui.js';
+import { renderBox, supportsUnicodeUi, terminalWidth } from './terminal-ui.js';
 
 export const colors = {
   reset: '\x1b[0m',
@@ -17,6 +17,15 @@ export const colors = {
   bgMagenta: '\x1b[45m',
 };
 
+const DARK_THEME = { cyan: '\x1b[36m', blue: '\x1b[34m', magenta: '\x1b[35m', white: '\x1b[37m', red: '\x1b[31m', yellow: '\x1b[33m', green: '\x1b[32m', dim: '\x1b[2m' };
+const LIGHT_THEME = { cyan: '\x1b[96m', blue: '\x1b[94m', magenta: '\x1b[95m', white: '\x1b[97m', red: '\x1b[91m', yellow: '\x1b[93m', green: '\x1b[92m', dim: '\x1b[2m' };
+
+export function applyColorTheme(theme = 'dark') {
+  const selected = String(theme || '').toLowerCase() === 'light' ? LIGHT_THEME : DARK_THEME;
+  Object.assign(colors, selected, { theme: String(theme || 'dark').toLowerCase() === 'light' ? 'light' : 'dark' });
+  return colors.theme;
+}
+
 const snowflakeArt = String.raw`
                           ii
                          .i;
@@ -42,7 +51,7 @@ const snowflakeArt = String.raw`
                            ;i. 
 `;
 
-export const miniLogo = `${colors.cyan}❄${colors.reset}`;
+export const miniLogo = `${colors.cyan}${supportsUnicodeUi() ? '❄' : '*'}${colors.reset}`;
 
 export function welcomeBanner(version, info = {}) {
   const pPath = info.project || 'Unknown';
@@ -54,7 +63,8 @@ export function welcomeBanner(version, info = {}) {
   // Tính toán chiều rộng động (nhỏ hơn 5% cửa sổ, tối thiểu 60, tối đa 100 cho đẹp)
   const columns = process.stdout.columns || 80;
   const W = Math.max(60, Math.min(Math.floor(columns * 0.95), 100));
-  const dot = `${colors.green}●${colors.reset}`;
+  const unicode = supportsUnicodeUi();
+  const dot = `${colors.green}${unicode ? '●' : '*'}${colors.reset}`;
 
   // Căn giữa Snowflake Art
   const artLines = snowflakeArt.split('\n').filter(l => l.trim() !== '' || l.length > 0);
@@ -92,13 +102,13 @@ ${renderBox({
 }
 
 export const statusIcons = {
-  online: `${colors.green}●${colors.reset}`,
-  offline: `${colors.dim}○${colors.reset}`,
-  warning: `${colors.yellow}◆${colors.reset}`,
-  error: `${colors.red}✖${colors.reset}`,
-  success: `${colors.green}✓${colors.reset}`,
-  thinking: `${colors.cyan}◉${colors.reset}`,
-  queue: `${colors.magenta}◎${colors.reset}`,
+  online: `${colors.green}${supportsUnicodeUi() ? '●' : 'on'}${colors.reset}`,
+  offline: `${colors.dim}${supportsUnicodeUi() ? '○' : 'off'}${colors.reset}`,
+  warning: `${colors.yellow}${supportsUnicodeUi() ? '◆' : '!'}${colors.reset}`,
+  error: `${colors.red}${supportsUnicodeUi() ? '✖' : 'x'}${colors.reset}`,
+  success: `${colors.green}${supportsUnicodeUi() ? '✓' : 'ok'}${colors.reset}`,
+  thinking: `${colors.cyan}${supportsUnicodeUi() ? '◉' : '...'}${colors.reset}`,
+  queue: `${colors.magenta}${supportsUnicodeUi() ? '◎' : 'queue'}${colors.reset}`,
 };
 
 export function sessionIndicator(sessionId) {

package/src/cli/terminal-ui.js

@@ -1,6 +1,6 @@
 const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
 const ZERO_WIDTH_PATTERN = /[\u200B-\u200D\u2060\uFE0E\uFE0F]/u;
-const WIDE_CODE_POINT_RANGES = [
+const WIDE_CODE_POINT_RANGES = [
   [0x1100, 0x115f],
   [0x2329, 0x232a],
   [0x2e80, 0x303e],
@@ -14,8 +14,30 @@ const WIDE_CODE_POINT_RANGES = [
   [0x1f300, 0x1f64f],
   [0x1f680, 0x1f6ff],
   [0x1f900, 0x1f9ff],
-  [0x1fa70, 0x1faff],
-];
+  [0x1fa70, 0x1faff],
+];
+
+const UNICODE_BOX = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+  teeLeft: '├',
+  teeRight: '┤',
+};
+
+const ASCII_BOX = {
+  topLeft: '+',
+  topRight: '+',
+  bottomLeft: '+',
+  bottomRight: '+',
+  horizontal: '-',
+  vertical: '|',
+  teeLeft: '+',
+  teeRight: '+',
+};
 
 export function stripAnsi(text) {
   return String(text ?? '').replace(ANSI_PATTERN, '');
@@ -41,10 +63,21 @@ export function charDisplayWidth(char) {
   return 1;
 }
 
-export function terminalWidth(min = 72, max = 120, fallback = 88) {
-  const columns = process.stdout.columns || fallback;
-  return Math.max(min, Math.min(columns - 2, max));
-}
+export function terminalWidth(min = 72, max = 120, fallback = 88) {
+  const columns = process.stdout.columns || fallback;
+  return Math.max(min, Math.min(columns - 2, max));
+}
+
+export function supportsUnicodeUi(env = process.env, platform = process.platform) {
+  if (env.WINTER_ASCII_UI === '1' || env.WINTER_ASCII_UI === 'true') return false;
+  if (env.WINTER_UNICODE_UI === '1' || env.WINTER_UNICODE_UI === 'true') return true;
+  if (platform !== 'win32') return true;
+  return Boolean(env.WT_SESSION || env.TERM_PROGRAM || env.TERM || env.ConEmuANSI === 'ON');
+}
+
+export function getBoxChars() {
+  return supportsUnicodeUi() ? UNICODE_BOX : ASCII_BOX;
+}
 
 export function padVisible(text, width, fill = ' ') {
   const visible = visibleWidth(text);
@@ -91,20 +124,38 @@ export function wrapText(text, width) {
   return output;
 }
 
-export function chunkText(text, width) {
-  const chars = Array.from(stripAnsi(text));
-  const chunks = [];
-  for (let i = 0; i < chars.length; i += width) {
-    chunks.push(chars.slice(i, i + width).join(''));
-  }
-  return chunks.length > 0 ? chunks : [''];
-}
-
-export function renderBox({ title = '', body = [], width, borderColor = '\x1b[35m', titleColor = '\x1b[36m', reset = '\x1b[0m' }) {
-  const innerWidth = Math.max(28, (width || terminalWidth()) - 4);
-  const top = `${borderColor}╭${'─'.repeat(innerWidth)}╮${reset}`;
-  const bottom = `${borderColor}╰${'─'.repeat(innerWidth)}╯${reset}`;
-  const lines = [];
+export function chunkText(text, width) {
+  const chars = Array.from(stripAnsi(text));
+  const chunks = [];
+  let current = '';
+  let currentWidth = 0;
+  for (const char of chars) {
+    const charWidth = charDisplayWidth(char);
+    if (current && currentWidth + charWidth > width) {
+      chunks.push(current);
+      current = '';
+      currentWidth = 0;
+    }
+    current += char;
+    currentWidth += charWidth;
+  }
+  if (current) chunks.push(current);
+  return chunks.length > 0 ? chunks : [''];
+}
+
+export function renderBox({
+  title = '',
+  body = [],
+  width,
+  borderColor = '\x1b[35m',
+  titleColor = '\x1b[36m',
+  reset = '\x1b[0m',
+  boxChars = getBoxChars(),
+} = {}) {
+  const innerWidth = Math.max(28, (width || terminalWidth()) - 4);
+  const top = `${borderColor}${boxChars.topLeft}${boxChars.horizontal.repeat(innerWidth)}${boxChars.topRight}${reset}`;
+  const bottom = `${borderColor}${boxChars.bottomLeft}${boxChars.horizontal.repeat(innerWidth)}${boxChars.bottomRight}${reset}`;
+  const lines = [];
   const titleText = title ? ` ${title} ` : '';
 
   if (titleText) {
@@ -115,44 +166,45 @@ export function renderBox({ title = '', body = [], width, borderColor = '\x1b[35
       const padding = Math.max(0, innerWidth - visible);
       const left = index === 0 ? Math.floor(padding / 2) : 0;
       const right = index === 0 ? padding - left : padding;
-      lines.push(`${borderColor}│${reset}${' '.repeat(left)}${titleColor}${plainSegment}${reset}${' '.repeat(right)}${borderColor}│${reset}`);
-    });
-    lines.push(`${borderColor}├${'─'.repeat(innerWidth)}┤${reset}`);
-  }
+      lines.push(`${borderColor}${boxChars.vertical}${reset}${' '.repeat(left)}${titleColor}${plainSegment}${reset}${' '.repeat(right)}${borderColor}${boxChars.vertical}${reset}`);
+    });
+    lines.push(`${borderColor}${boxChars.teeLeft}${boxChars.horizontal.repeat(innerWidth)}${boxChars.teeRight}${reset}`);
+  }
 
   for (const item of body) {
     const rawText = String(item ?? '');
     if (visibleWidth(rawText) <= innerWidth) {
       const visible = visibleWidth(rawText);
       const padding = Math.max(0, innerWidth - visible);
-      lines.push(`${borderColor}│${reset} ${rawText}${' '.repeat(Math.max(0, padding - 1))}${borderColor}│${reset}`);
-      continue;
-    }
+      lines.push(`${borderColor}${boxChars.vertical}${reset} ${rawText}${' '.repeat(Math.max(0, padding - 1))}${borderColor}${boxChars.vertical}${reset}`);
+      continue;
+    }
 
     const wrapped = wrapText(rawText, innerWidth);
     if (wrapped.length === 0) {
-      lines.push(`${borderColor}│${reset} ${' '.repeat(Math.max(0, innerWidth - 1))}${borderColor}│${reset}`);
-      continue;
-    }
+      lines.push(`${borderColor}${boxChars.vertical}${reset} ${' '.repeat(Math.max(0, innerWidth - 1))}${borderColor}${boxChars.vertical}${reset}`);
+      continue;
+    }
 
     for (const segment of wrapped) {
       const text = stripAnsi(segment);
       const visible = visibleWidth(text);
       const padding = Math.max(0, innerWidth - visible);
-      lines.push(`${borderColor}│${reset} ${text}${' '.repeat(Math.max(0, padding - 1))}${borderColor}│${reset}`);
-    }
-  }
+      lines.push(`${borderColor}${boxChars.vertical}${reset} ${text}${' '.repeat(Math.max(0, padding - 1))}${borderColor}${boxChars.vertical}${reset}`);
+    }
+  }
 
   return [top, ...lines, bottom].join('\n');
 }
 
-export function renderKeyValueRows(rows, width, colors) {
-  const innerWidth = Math.max(28, (width || terminalWidth()) - 4);
-  return rows.map(([left, right]) => {
+export function renderKeyValueRows(rows, width, colors) {
+  const innerWidth = Math.max(28, (width || terminalWidth()) - 4);
+  const boxChars = getBoxChars();
+  return rows.map(([left, right]) => {
     const leftWidth = Math.floor(innerWidth * 0.5);
     const rightWidth = innerWidth - leftWidth - 1;
     const leftText = padVisible(left, leftWidth);
     const rightText = padVisible(right, rightWidth);
-    return `${colors.border}│${colors.reset} ${leftText}${colors.spacer}${rightText} ${colors.border}│${colors.reset}`;
-  });
-}
+    return `${colors.border}${boxChars.vertical}${colors.reset} ${leftText}${colors.spacer}${rightText} ${colors.border}${boxChars.vertical}${colors.reset}`;
+  });
+}

package/src/cli/tool-call-adapter.js

@@ -0,0 +1,327 @@
+export function normalizeToolCalls(toolCalls, parseArguments = parseToolArguments) {
+  if (!Array.isArray(toolCalls)) return [];
+
+  return toolCalls.map((tc, index) => {
+    const fn = tc.function || {};
+    const rawArgs = fn.arguments ?? tc.arguments ?? tc.input ?? {};
+    const parsedArgs = parseArguments(rawArgs);
+    const nested = extractToolPayload(parsedArgs, parseArguments);
+    const nestedName = nested.name;
+    const nestedArgs = nested.args;
+    const direct = extractToolPayload(tc, parseArguments);
+    const fnPayload = extractToolPayload(fn, parseArguments);
+    const toolName = fnPayload.name || direct.name || nestedName || tc.name || tc.tool_name || fn.name;
+    const toolArgs = fnPayload.args ?? direct.args ?? nestedArgs ?? parsedArgs;
+
+    return {
+      ...tc,
+      id: tc.id || `call-${index}`,
+      toolName,
+      toolArgs,
+    };
+  }).filter(call => typeof call.toolName === 'string' && call.toolName.trim() !== '' && call.toolName !== 'function');
+}
+
+export function extractInlineToolCalls(content, idFactory = index => `inline-${Date.now()}-${index}`) {
+  const text = String(content || '');
+  const toolCalls = [];
+  let cleaned = text;
+  const pushToolCall = (name, args, source = 'inline') => {
+    toolCalls.push({
+      id: idFactory(toolCalls.length),
+      source,
+      type: 'function',
+      function: {
+        name,
+        arguments: typeof args === 'string' ? args : JSON.stringify(args || {}),
+      },
+    });
+  };
+  const pushParsedToolObject = (parsed) => {
+    const { name, args } = extractToolPayload(parsed, parseToolArguments);
+    if (!name || typeof name !== 'string') return false;
+    pushToolCall(name, args, 'object');
+    return true;
+  };
+
+  const invokePattern = /(?:<[\w.-]+:tool_call>\s*)?<invoke\s+name=["']([^"']+)["']>([\s\S]*?)<\/invoke>\s*(?:<\/[\w.-]+:tool_call>)?/gi;
+  cleaned = cleaned.replace(invokePattern, (_match, name, body) => {
+    const args = {};
+    const paramPattern = /<parameter\s+name=["']([^"']+)["']>([\s\S]*?)<\/parameter>/gi;
+    let param;
+    while ((param = paramPattern.exec(body))) {
+      args[param[1]] = decodeXmlEntities(param[2].trim());
+    }
+    pushToolCall(name, args, 'xml-invoke');
+    return '';
+  }).trim();
+
+  const namedToolPattern = /<tool_call\s+name=["']([^"']+)["']>([\s\S]*?)<\/tool_call>/gi;
+  cleaned = cleaned.replace(namedToolPattern, (_match, name, body) => {
+    pushToolCall(name, decodeXmlEntities(body.trim()), 'xml-tool-call');
+    return '';
+  }).trim();
+
+  const genericNamedToolPattern = /<(?:tool|function_call|call)\s+name=["']([^"']+)["']>([\s\S]*?)<\/(?:tool|function_call|call)>/gi;
+  cleaned = cleaned.replace(genericNamedToolPattern, (_match, name, body) => {
+    pushToolCall(name, decodeXmlEntities(body.trim()), 'xml-generic');
+    return '';
+  }).trim();
+
+  const jsonToolPattern = /<tool_call>([\s\S]*?)<\/tool_call>/gi;
+  cleaned = cleaned.replace(jsonToolPattern, (_match, body) => {
+    const parsed = parseToolArguments(decodeXmlEntities(body.trim()));
+    const name = parsed.name || parsed.tool || parsed.tool_name;
+    const args = parsed.arguments ?? parsed.args ?? parsed.input ?? parsed;
+    if (name) pushToolCall(name, args, 'xml-json-tool-call');
+    return name ? '' : _match;
+  }).trim();
+
+  const functionPattern = /<function(?:\s+name=["']([^"']+)["']|=([^>\s]+))>([\s\S]*?)<\/function>/gi;
+  cleaned = cleaned.replace(functionPattern, (_match, quotedName, bareName, body) => {
+    pushToolCall(quotedName || bareName, decodeXmlEntities(body.trim()), 'xml-function');
+    return '';
+  }).trim();
+
+  const fencedToolPattern = /```(?:tool|tool_call|function)\s*\n([\s\S]*?)```/gi;
+  cleaned = cleaned.replace(fencedToolPattern, (_match, body) => {
+    const trimmed = body.trim();
+    const parsed = parseToolArguments(trimmed);
+    const name = parsed.name || parsed.tool || parsed.tool_name;
+    if (name) {
+      pushToolCall(name, parsed.arguments ?? parsed.args ?? parsed.input ?? parsed, 'fenced-tool-json');
+      return '';
+    }
+    const lineMatch = trimmed.match(/^([A-Za-z][\w.-]*)\s+([\s\S]+)$/);
+    if (lineMatch) {
+      pushToolCall(lineMatch[1], lineMatch[2].trim(), 'fenced-tool-line');
+      return '';
+    }
+    return _match;
+  }).trim();
+
+  const fencedJsonToolPattern = /```(?:json|javascript|js)?\s*\n([\s\S]*?)```/gi;
+  cleaned = cleaned.replace(fencedJsonToolPattern, (_match, body) => {
+    const parsed = parseToolArguments(body.trim());
+    if (Array.isArray(parsed)) {
+      const startCount = toolCalls.length;
+      for (const item of parsed) pushParsedToolObject(item);
+      return toolCalls.length > startCount ? '' : _match;
+    }
+    return pushParsedToolObject(parsed) ? '' : _match;
+  }).trim();
+
+  const labeledToolPattern = /(?:^|\n)\s*(?:tool|tool_name|function|call_tool|call|action)\s*[:=]\s*([A-Za-z][\w.-]*)\s*(?:\n|\r\n?)\s*(?:arguments|args|input|parameters|params)\s*[:=]\s*([\s\S]*?)(?=\n\s*(?:tool|tool_name|function|call_tool|call|action)\s*[:=]|\n\s*$|$)/gi;
+  cleaned = cleaned.replace(labeledToolPattern, (_match, name, args) => {
+    pushToolCall(name, args.trim(), 'labeled-text');
+    return '';
+  }).trim();
+
+  const commandToolPattern = /(?:^|\n)\s*(?:CALL_TOOL|TOOL_CALL|USE_TOOL|RUN_TOOL|@tool)\s+([A-Za-z][\w.-]*)\s+({[\s\S]*?})(?=\n|$)/gi;
+  cleaned = cleaned.replace(commandToolPattern, (_match, name, args) => {
+    pushToolCall(name, args.trim(), 'command-text');
+    return '';
+  }).trim();
+
+  const trimmedCleaned = cleaned.trim();
+  if (trimmedCleaned) {
+    const parsed = parseToolArguments(trimmedCleaned);
+    if (Array.isArray(parsed)) {
+      const startCount = toolCalls.length;
+      for (const item of parsed) pushParsedToolObject(item);
+      if (toolCalls.length > startCount) cleaned = '';
+    } else if (pushParsedToolObject(parsed)) {
+      cleaned = '';
+    }
+  }
+
+  return { content: cleaned, toolCalls };
+}
+
+export function decodeXmlEntities(value) {
+  return String(value || '')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, '&');
+}
+
+export function parseToolArguments(rawArgs) {
+  if (!rawArgs) return {};
+  if (typeof rawArgs === 'object') return rawArgs;
+  if (typeof rawArgs !== 'string') return {};
+
+  const text = rawArgs.trim();
+  if (!text) return {};
+
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    const extracted = extractFirstJsonValue(text);
+    if (extracted && extracted !== text) {
+      try {
+        return JSON.parse(extracted);
+      } catch {}
+    }
+
+    for (const repaired of buildJsonRepairCandidates(extracted || text)) {
+      try {
+        return JSON.parse(repaired);
+      } catch {}
+    }
+
+    return {
+      __toolArgParseError: error.message,
+      __rawToolArgs: text.length > 800 ? `${text.slice(0, 800)}...` : text,
+    };
+  }
+}
+
+export function buildJsonRepairCandidates(text) {
+  const value = String(text || '').trim();
+  if (!value) return [];
+  const candidates = [];
+
+  candidates.push(
+    value
+      .replace(/([{,]\s*)([A-Za-z_$][\w$-]*)(\s*:)/g, '$1"$2"$3')
+      .replace(/:\s*'([^'\\]*(?:\\.[^'\\]*)*)'/g, (_m, inner) => `: "${inner.replace(/"/g, '\\"')}"`)
+      .replace(/:\s*([^'",{}\[\]\r\n][^,}\]\r\n]*)/g, (_m, inner) => {
+        const trimmed = inner.trim();
+        if (trimmed.startsWith('"')) return `: ${trimmed}`;
+        if (/^(true|false|null|-?\d+(?:\.\d+)?)$/i.test(trimmed)) return `: ${trimmed}`;
+        return `: "${trimmed.replace(/"/g, '\\"')}"`;
+      })
+      .replace(/,\s*([}\]])/g, '$1')
+  );
+
+  candidates.push(
+    value
+      .replace(/'/g, '"')
+      .replace(/,\s*([}\]])/g, '$1')
+  );
+
+  return [...new Set(candidates)].filter(candidate => candidate && candidate !== value);
+}
+
+export function extractFirstJsonObject(text) {
+  const extracted = extractFirstJsonValue(text);
+  if (!extracted || extracted[0] !== '{') return null;
+  return extracted;
+}
+
+export function extractFirstJsonValue(text) {
+  const source = String(text || '');
+  const objectStart = source.indexOf('{');
+  const arrayStart = source.indexOf('[');
+  if (objectStart === -1 && arrayStart === -1) return null;
+  const startIndex = objectStart === -1
+    ? arrayStart
+    : arrayStart === -1
+      ? objectStart
+      : Math.min(objectStart, arrayStart);
+
+  const openChar = source[startIndex];
+  const closeChar = openChar === '[' ? ']' : '}';
+
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let i = startIndex; i < source.length; i++) {
+    const ch = source[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === '\\') {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === openChar) depth++;
+    if (ch === closeChar) {
+      depth--;
+      if (depth === 0) return source.slice(startIndex, i + 1);
+    }
+  }
+
+  return null;
+}
+
+function extractToolPayload(payload, parseArguments) {
+  if (!payload || typeof payload !== 'object') {
+    return { name: null, args: undefined };
+  }
+
+  // Anthropic / Claude style content block: { type: "tool_use", name, input }
+  if (payload.type === 'tool_use' && typeof payload.name === 'string') {
+    return { name: payload.name, args: payload.input ?? payload.arguments ?? {} };
+  }
+
+  // OpenAI Responses style function-call object
+  if (payload.type === 'function' && typeof payload.name === 'string') {
+    return { name: payload.name, args: parseArguments(payload.arguments ?? payload.input ?? {}) };
+  }
+
+  // Gemini style object: { functionCall: { name, args } }
+  if (payload.functionCall && typeof payload.functionCall === 'object') {
+    return {
+      name: payload.functionCall.name || null,
+      args: payload.functionCall.args ?? payload.functionCall.arguments ?? {},
+    };
+  }
+
+  const nestedFunction = payload.function && typeof payload.function === 'object' ? payload.function : null;
+  const name = payload.name
+    || payload.tool
+    || payload.tool_name
+    || payload.action
+    || payload.function_name
+    || nestedFunction?.name
+    || null;
+
+  const args = payload.arguments
+    ?? payload.args
+    ?? payload.input
+    ?? payload.parameters
+    ?? payload.params
+    ?? payload.tool_input
+    ?? payload.function_arguments
+    ?? nestedFunction?.arguments
+    ?? nestedFunction?.input
+    ?? {};
+
+  const normalizedName = typeof name === 'string' ? name : null;
+  return {
+    name: normalizedName,
+    args: normalizedName ? parseArguments(args) : undefined,
+  };
+}
+
+export function formatToolCallsForMessage(toolCalls) {
+  return toolCalls.map((tc) => ({
+    id: tc.id,
+    type: 'function',
+    function: {
+      name: tc.toolName || tc.function?.name || 'unknown',
+      arguments: JSON.stringify(tc.toolArgs || {}),
+    },
+  }));
+}
+
+export function buildToolCallSignature(toolCalls, normalizeToolName = name => name) {
+  if (!Array.isArray(toolCalls) || toolCalls.length === 0) return '';
+
+  return toolCalls.map((tc) => {
+    const rawName = tc.toolName || tc.function?.name || tc.type || '';
+    const toolName = normalizeToolName(rawName) || rawName;
+    const toolArgs = tc.toolArgs && typeof tc.toolArgs === 'object' ? tc.toolArgs : {};
+    return `${toolName}:${JSON.stringify(toolArgs)}`;
+  }).join(' | ');
+}