Description

buildChatItems() now calls resolveHistoryStartIndex() which estimates the rendered size of each message to enforce a char budget. This estimation walks raw message payloads recursively via estimateRawContentChars().

• estimateRawContentChars() recursively traverses arrays and record.content with no max depth / node limit and no cycle detection.
• A deeply nested content structure (e.g., nested tool_result blocks) can cause stack overflow or long synchronous traversal on the UI thread, freezing the chat UI.
• If a cyclic object graph ever enters messages (e.g., via in-memory composition, plugin/tool code, or non-JSON sources), recursion becomes infinite.

Vulnerable code:

function estimateRawContentChars(value: unknown): number {
  if (Array.isArray(value)) {
    return value.reduce((total, item) => total + estimateRawContentChars(item), 0);
  }
  ...
  if (record.content !== undefined) {
    chars += estimateRawContentChars(record.content);
  }
  return chars;
}

Recommendation

Make the estimator bounded and cycle-safe, and short-circuit once the budget is exceeded.

Suggested approach:

• Track visited objects in a WeakSet<object> to prevent cycles.
• Add a maxDepth and/or maxNodes cap.
• Add an optional remainingBudget parameter to stop walking once remainingBudget <= 0.

Example:

function estimateRawContentCharsSafe(
  value: unknown,
  opts: { remaining: number; depth: number; maxDepth: number; visited: WeakSet<object> },
): number {
  if (opts.remaining <= 0) return 0;
  if (typeof value === "string") return Math.min(value.length, opts.remaining);

  if (!value || typeof value !== "object") return 0;
  if (opts.depth >= opts.maxDepth) return 0;
  if (opts.visited.has(value)) return 0;
  opts.visited.add(value);

  if (Array.isArray(value)) {
    let total = 0;
    for (const item of value) {
      const n = estimateRawContentCharsSafe(item, { ...opts, remaining: opts.remaining - total, depth: opts.depth + 1 });
      total += n;
      if (total >= opts.remaining) break;
    }
    return total;
  }

  const record = value as Record<string, unknown>;
  let total = 0;
  if (typeof record.text === "string") total += Math.min(record.text.length, opts.remaining - total);
  if (record.content !== undefined && total < opts.remaining) {
    total += estimateRawContentCharsSafe(record.content, { ...opts, remaining: opts.remaining - total, depth: opts.depth + 1 });
  }
  return total;
}

Then call this from estimateMessageRenderChars() with remaining set to (CHAT_HISTORY_RENDER_CHAR_BUDGET - charsSoFar) (or a per-message cap) so the walk cannot dominate the UI thread.

Description

The chat history rendering path can crash the UI when a malformed/partial message (e.g., null, undefined, or a non-object primitive) is present in props.messages.

• normalizeMessage(message) assumes message is an object (const m = message as Record<string, unknown>; and then accesses m.role, m.content, etc.). If message is null/undefined, this throws a TypeError.
• This change introduces additional pre-render passes over history (resolveHistoryStartIndex, countVisibleHistoryMessages) that call normalizeMessage() via isHiddenToolMessage() and estimateMessageRenderChars().
• As a result, a single bad persisted/provider message can take down the entire chat UI earlier (before the main render loop), constituting an availability/DoS issue.

Vulnerable code:

function isHiddenToolMessage(message: unknown, showToolCalls: boolean): boolean {
  return !showToolCalls && normalizeMessage(message).role.toLowerCase() === "toolresult";
}

Recommendation

Make history trimming tolerant of malformed message entries.

Options:

1. Harden normalizeMessage to safely handle null/non-objects by treating them as an unknown message with empty content.
2. Or guard at call sites (recommended here since these helpers are used in tight loops): use a small safe wrapper with try/catch and/or an object check.

Example fix (call-site wrapper):

function safeNormalizeMessage(message: unknown) {
  try {
    if (!message || typeof message !== "object") {
      return { role: "unknown", content: [], timestamp: Date.now() };
    }
    return normalizeMessage(message);
  } catch {
    return { role: "unknown", content: [], timestamp: Date.now() };
  }
}

function isHiddenToolMessage(message: unknown, showToolCalls: boolean): boolean {
  const normalized = safeNormalizeMessage(message);
  return !showToolCalls && normalized.role.toLowerCase() === "toolresult";
}

This prevents a single malformed message in persisted/provider history from crashing chat rendering.

Best possible solution:

Keep the current-main implementation from the merged replacement and close this conflicting source branch instead of rebasing it.

Do we have a high-confidence way to reproduce the issue?

Yes for the historical bug path from source and linked report context, but no current-main failing reproduction remains. Current main now budgets chat history by count and render characters with focused regression coverage.

Is this the best way to solve the issue?

Yes for current main, not for this branch. The merged replacement is the narrower maintainable solution because it preserves the 100-message cap and bounds estimator traversal, while the source branch still carries obsolete/conflicting behavior.

Security review:

Security review needs attention: The source branch has a concrete client-side availability concern from unbounded recursive history-size estimation; current main's replacement bounds that traversal.

• [medium] Unbounded recursive history traversal — ui/src/ui/chat/build-chat-items.ts:154
  estimateRawContentChars on the source branch descends through arrays and nested content without cycle, depth, node, or remaining-budget limits, so malformed history content can monopolize the UI thread or overflow the stack during pre-render trimming.
  Confidence: 0.82

What I checked:

• Current source: limits: Current main keeps the responsive-refresh 100-message cap and adds CHAT_HISTORY_RENDER_CHAR_BUDGET = 240_000. (ui/src/ui/chat/history-limits.ts:1, 238b0fc76fa7)
• Current source: bounded estimator: Current main estimates raw content/text/args with a remaining budget, max depth, max node count, and WeakSet cycle guard before resolving the visible history window. (ui/src/ui/chat/build-chat-items.ts:330, 238b0fc76fa7)
• Current source: render window: resolveHistoryStartIndex applies the visible message cap and 240k character budget before buildChatItems renders history, while counting hidden/visible notices from visible messages. (ui/src/ui/chat/build-chat-items.ts:429, 238b0fc76fa7)
• Regression coverage: Current tests cover tool_result.content budget accounting and malformed history entries, matching the prior review/security concerns on the source branch. (ui/src/ui/chat/build-chat-items.test.ts:239, 238b0fc76fa7)
• Fix provenance: Merge commit 348ffe6 states it caps Control UI chat history by raw tool-output size, including tool_result.content, with bounded estimation; it was committed on 2026-05-14T10:36:09Z. (348ffe60612c)
• Merged replacement PR: fix(gateway): stop stale control ui auth retry loops #81771 is merged and explicitly says it adds the chat-history render character budget, preserves the 100-message cap, counts raw tool_result.content, and bounds estimator traversal. (348ffe60612c)

Likely related people:

• BunsDev: Authored and merged the current-main replacement that includes the bounded chat-history budget, and recently introduced the current 100-message Control UI render cap. (role: recent area contributor and merger; confidence: high; commits: 348ffe60612c, d9692555ee0f, 5ae385b2f0f1; files: ui/src/ui/chat/build-chat-items.ts, ui/src/ui/chat/history-limits.ts, ui/src/ui/controllers/chat.ts)
• vincentkoc: Pushed the narrow repair commit to this source branch and has recent current-main work in WebChat reload/final-state reconciliation adjacent to the affected path. (role: adjacent area contributor; confidence: medium; commits: 9f08eefa67a6, cff991c88d04, 02908db62b30; files: ui/src/ui/chat/build-chat-items.ts, ui/src/ui/controllers/chat.ts)
• steipete: Recent history shows chat item builder test extraction, role-normalization import work, and related chat display maintenance around this UI history surface. (role: adjacent area contributor; confidence: medium; commits: 68954f9c6ccb, f62a054ef1ac, f739edcf4c7e; files: ui/src/ui/chat/build-chat-items.ts, ui/src/ui/chat/history-limits.ts, src/gateway/chat-display-projection.ts)

Codex review notes: model gpt-5.5, reasoning high; reviewed against 238b0fc76fa7; fix evidence: commit 348ffe60612c, main fix timestamp 2026-05-14T10:36:09Z.