import type { ChatItem, MessageGroup, ToolCard } from "../types/chat-types.ts";

import type { ChatItem, MessageGroup, NormalizedMessage, ToolCard } from "../types/chat-types.ts";

import {

isAssistantHeartbeatAckForDisplay,

stripHeartbeatTokenForDisplay,

} from "./heartbeat-display.ts";

import { CHAT_HISTORY_RENDER_LIMIT } from "./history-limits.ts";

import { CHAT_HISTORY_RENDER_CHAR_BUDGET, CHAT_HISTORY_RENDER_LIMIT } from "./history-limits.ts";

import { extractTextCached } from "./message-extract.ts";

import { normalizeMessage, stripMessageDisplayMetadataText } from "./message-normalizer.ts";

import { normalizeRoleForGrouping } from "./role-normalizer.ts";

};

}

function asRecord(value: unknown): Record<string, unknown> | null {

return value && typeof value === "object" && !Array.isArray(value)

? (value as Record<string, unknown>)

: null;

}

function safeNormalizeMessage(message: unknown): NormalizedMessage | null {

if (!asRecord(message)) {

return null;

}

try {

return normalizeMessage(message);

} catch {

return null;

}

}

function extractChatMessagePreview(toolMessage: unknown): {

preview: Extract<NonNullable<ToolCard["preview"]>, { kind: "canvas" }>;

text: string | null;

timestamp: number | null;

} | null {

const normalized = normalizeMessage(toolMessage);

const normalized = safeNormalizeMessage(toolMessage);

if (!normalized) {

return null;

}

const cards = extractToolCards(toolMessage, "preview");

for (let index = cards.length - 1; index >= 0; index--) {

const card = cards[index];

}

return {

index,

timestamp: normalizeMessage(item.message).timestamp ?? null,

timestamp: safeNormalizeMessage(item.message)?.timestamp ?? null,

};

})

.filter(Boolean) as Array<{ index: number; timestamp: number | null }>;

}

function collapseDuplicateDisplaySignature(message: unknown): string | null {

const normalized = normalizeMessage(message);

const normalized = safeNormalizeMessage(message);

if (!normalized) {

return null;

}

const role = normalizeRoleForGrouping(normalized.role).toLowerCase();

if (!role || role === "tool") {

return null;

}

function hasRenderableNormalizedMessage(message: unknown): boolean {

const normalized = normalizeMessage(message);

const normalized = safeNormalizeMessage(message);

if (!normalized) {

return false;

}

return normalized.content.length > 0 || Boolean(normalized.replyTarget);

}

}

function rawMessageTimestamp(message: unknown): number | null {

const timestamp = (message as { timestamp?: unknown }).timestamp;

const timestamp = asRecord(message)?.timestamp;

return typeof timestamp === "number" && Number.isFinite(timestamp) ? timestamp : null;

}

.map(({ item }) => item);

}

type RawContentEstimateState = {

visited: WeakSet<object>;

nodes: number;

};

const RAW_CONTENT_ESTIMATE_MAX_DEPTH = 8;

const RAW_CONTENT_ESTIMATE_MAX_NODES = 400;

function addCapped(total: number, amount: number, limit: number): number {

return Math.min(limit, total + Math.max(0, amount));

}

function estimateRawContentChars(

value: unknown,

limit: number,

state: RawContentEstimateState,

depth = 0,

): number {

if (limit <= 0) {

return 0;

}

if (typeof value === "string") {

return Math.min(value.length, limit);

}

if (!value || typeof value !== "object") {

return 0;

}

if (depth >= RAW_CONTENT_ESTIMATE_MAX_DEPTH || state.nodes >= RAW_CONTENT_ESTIMATE_MAX_NODES) {

return 0;

}

if (state.visited.has(value)) {

return 0;

}

state.visited.add(value);

state.nodes += 1;

if (Array.isArray(value)) {

let chars = 0;

for (const item of value) {

chars = addCapped(

chars,

estimateRawContentChars(item, limit - chars, state, depth + 1),

limit,

);

if (chars >= limit) {

break;

}

}

return chars;

}

const record = value as Record<string, unknown>;

let chars = 0;

for (const key of ["text", "content", "args", "arguments", "input"] as const) {

chars = addCapped(

chars,

estimateRawContentChars(record[key], limit - chars, state, depth + 1),

limit,

);

if (chars >= limit) {

break;

}

}

return chars;

}

function estimateMessageRenderChars(message: unknown, limit: number): number {

const record = asRecord(message);

if (!record) {

return 1;

}

const state: RawContentEstimateState = { visited: new WeakSet<object>(), nodes: 0 };

let chars = 0;

for (const key of ["content", "text", "args", "arguments", "input"] as const) {

chars = addCapped(chars, estimateRawContentChars(record[key], limit - chars, state), limit);

if (chars >= limit) {

break;

}

}

return Math.max(chars, 1);

}

function isHiddenToolMessage(message: unknown, showToolCalls: boolean): boolean {

if (showToolCalls) {

return false;

}

return safeNormalizeMessage(message)?.role.toLowerCase() === "toolresult";

}

function countVisibleHistoryMessages(messages: unknown[], showToolCalls: boolean): number {

let count = 0;

for (const message of messages) {

if (!isHiddenToolMessage(message, showToolCalls)) {

count += 1;

}

}

return count;

}

function resolveHistoryStartIndex(messages: unknown[], showToolCalls: boolean): number {

let visibleCount = 0;

let renderChars = 0;

let startIndex = messages.length;

for (let index = messages.length - 1; index >= 0; index -= 1) {

const message = messages[index];

if (isHiddenToolMessage(message, showToolCalls)) {

continue;

}

if (visibleCount >= CHAT_HISTORY_RENDER_LIMIT) {

break;

}

const remainingBudget = Math.max(1, CHAT_HISTORY_RENDER_CHAR_BUDGET - renderChars + 1);

const messageChars = estimateMessageRenderChars(message, remainingBudget);

if (visibleCount > 0 && renderChars + messageChars > CHAT_HISTORY_RENDER_CHAR_BUDGET) {

break;

}

renderChars += messageChars;

visibleCount += 1;

startIndex = index;

}

return startIndex;

}

export function buildChatItems(props: BuildChatItemsProps): Array<ChatItem | MessageGroup> {

let items: ChatItem[] = [];

const history = (Array.isArray(props.messages) ? props.messages : []).filter(

text: string | null;

timestamp: number | null;

}>;

const historyStart = Math.max(0, history.length - CHAT_HISTORY_RENDER_LIMIT);

if (historyStart > 0) {

const historyStart = resolveHistoryStartIndex(history, props.showToolCalls);

const hiddenHistoryCount = countVisibleHistoryMessages(

history.slice(0, historyStart),

props.showToolCalls,

);

const visibleHistoryCount = countVisibleHistoryMessages(

history.slice(historyStart),

props.showToolCalls,

);

if (hiddenHistoryCount > 0) {

items.push({

kind: "message",

key: "chat:history:notice",

message: {

role: "system",

content: `Showing last ${CHAT_HISTORY_RENDER_LIMIT} messages (${historyStart} hidden).`,

content: `Showing last ${visibleHistoryCount} messages (${hiddenHistoryCount} hidden).`,

timestamp: Date.now(),

},

});

}

for (let i = historyStart; i < history.length; i++) {

const msg = history[i];

const normalized = normalizeMessage(msg);

const raw = msg as Record<string, unknown>;

const normalized = safeNormalizeMessage(msg);

if (!normalized) {

continue;

}

const raw = asRecord(msg) ?? {};

const marker = raw.__openclaw as Record<string, unknown> | undefined;

if (marker && marker.kind === "compaction") {

items.push({

}

function messageKey(message: unknown, index: number): string {

const m = message as Record<string, unknown>;

const m = asRecord(message) ?? {};

const toolCallId = typeof m.toolCallId === "string" ? m.toolCallId : "";

if (toolCallId) {

const role = typeof m.role === "string" ? m.role : "unknown";