return readStringValue((message as { role?: unknown }).role);

}

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

type ImportedExternalIdentity = {

externalId: string;

importedFrom?: string;

cliSessionId?: string;

};

function resolveImportedExternalIdentity(message: unknown): ImportedExternalIdentity | undefined {

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

return undefined;

}

typeof (message as { __openclaw?: unknown })["__openclaw"] === "object"

? ((message as { __openclaw?: Record<string, unknown> })["__openclaw"] ?? {})

: undefined;

return normalizeOptionalString(meta?.externalId);

const externalId = normalizeOptionalString(meta?.externalId);

return externalId

? {

externalId,

importedFrom: normalizeOptionalString(meta?.importedFrom),

cliSessionId: normalizeOptionalString(meta?.cliSessionId),

}

: undefined;

}

function hasSameExternalIdentity(existing: unknown, imported: unknown): boolean {

const importedIdentity = resolveImportedExternalIdentity(imported);

const existingIdentity = resolveImportedExternalIdentity(existing);

if (!importedIdentity || !existingIdentity) {

return false;

}

return (

importedIdentity.externalId === existingIdentity.externalId &&

importedIdentity.importedFrom === existingIdentity.importedFrom &&

importedIdentity.cliSessionId === existingIdentity.cliSessionId

);

}

function isEquivalentImportedMessage(existing: unknown, imported: unknown): boolean {

const importedExternalId = resolveImportedExternalId(imported);

if (importedExternalId && resolveImportedExternalId(existing) === importedExternalId) {

if (hasSameExternalIdentity(existing, imported)) {

return true;

}

if (aTimestamp !== undefined && bTimestamp !== undefined && aTimestamp !== bTimestamp) {

return aTimestamp - bTimestamp;

}

if (aTimestamp !== undefined && bTimestamp === undefined) {

return -1;

}

if (aTimestamp === undefined && bTimestamp !== undefined) {

return 1;

}

return a.order - b.order;

}