extractJsonNullableStringFieldPrefix,

extractJsonNumberFieldPrefix,

extractJsonStringFieldPrefix,

normalizeOptionalString,

} from "./session-transcript-json.js";

import type { SessionPreviewItem } from "./session-utils.types.js";

};

}

function readTranscriptMessageIdempotencyKey(message: unknown): string | undefined {

if (!message || typeof message !== "object" || Array.isArray(message)) {

return undefined;

}

const value = (message as Record<string, unknown>).idempotencyKey;

return typeof value === "string" && value.trim() ? value : undefined;

}

/** Read all visible transcript messages for a session from the first existing candidate file. */

export function readSessionMessages(

sessionId: string,

const MAX_TRANSCRIPT_PARSE_LINE_BYTES = 256 * 1024;

const OVERSIZED_TRANSCRIPT_METADATA_PREFIX_CHARS = 64 * 1024;

const OVERSIZED_TRANSCRIPT_METADATA_SUFFIX_CHARS = 64 * 1024;

const TRANSCRIPT_OVERSIZED_MESSAGE_PLACEHOLDER = "[chat.history omitted: message too large]";

function isOversizedTranscriptLine(line: string): boolean {

return Buffer.byteLength(line, "utf8") > MAX_TRANSCRIPT_PARSE_LINE_BYTES;

}

function isJsonObjectFieldToken(source: string, tokenIndex: number): boolean {

for (let index = tokenIndex - 1; index >= 0; index--) {

const char = source[index];

if (/\s/.test(char)) {

continue;

}

return char === "{" || char === ",";

}

return true;

}

function extractJsonStringFieldWindow(

source: string,

field: string,

startIndex = 0,

endIndex = source.length,

): string | undefined {

const fieldToken = JSON.stringify(field);

let searchIndex = startIndex;

while (searchIndex < endIndex) {

const tokenIndex = source.indexOf(fieldToken, searchIndex);

if (tokenIndex < 0 || tokenIndex >= endIndex) {

return undefined;

}

searchIndex = tokenIndex + fieldToken.length;

if (!isJsonObjectFieldToken(source, tokenIndex)) {

continue;

}

const match = /^\s*:\s*"((?:\\.|[^"\\])*)"/.exec(source.slice(searchIndex, endIndex));

if (!match) {

continue;

}

try {

const decoded = JSON.parse(`"${match[1]}"`) as unknown;

return normalizeOptionalString(decoded);

} catch {

return undefined;

}

}

return undefined;

}

function extractJsonStringFieldSuffix(source: string, field: string): string | undefined {

const startIndex = Math.max(0, source.length - OVERSIZED_TRANSCRIPT_METADATA_SUFFIX_CHARS);

return extractJsonStringFieldWindow(source, field, startIndex);

}

function buildOversizedTranscriptRecord(line: string): TailTranscriptRecord {

const prefix = line.slice(0, OVERSIZED_TRANSCRIPT_METADATA_PREFIX_CHARS);

const messageMatch = /"message"\s*:/.exec(prefix);

extractJsonStringFieldPrefix(recordPrefix, "timestamp") ??

extractJsonNumberFieldPrefix(recordPrefix, "timestamp");

const role = extractJsonStringFieldPrefix(prefix, "role") ?? "assistant";

const idempotencyKey =

extractJsonStringFieldPrefix(prefix, "idempotencyKey") ??

extractJsonStringFieldSuffix(line, "idempotencyKey");

const record: Record<string, unknown> = {

...(type ? { type } : {}),

...(id ? { id } : {}),

...(parentId !== undefined ? { parentId } : {}),

...(timestamp !== undefined ? { timestamp } : {}),

message: {

role,

...(idempotencyKey ? { idempotencyKey } : {}),

content: [{ type: "text", text: TRANSCRIPT_OVERSIZED_MESSAGE_PLACEHOLDER }],

__openclaw: { truncated: true, reason: "oversized" },

},

: typeof entry.timestamp === "number"

? entry.timestamp

: Number.NaN;

const idempotencyKey = readTranscriptMessageIdempotencyKey(entry.message);

return attachOpenClawTranscriptMeta(entry.message, {

...(typeof entry.id === "string" ? { id: entry.id } : {}),

...(idempotencyKey ? { idempotencyKey } : {}),

...(Number.isFinite(recordTimestampMs) ? { recordTimestampMs } : {}),

seq,

});