resolveSessionFilePathOptions,

resolveStorePath,

} from "../../config/sessions.js";

import type { SessionEntry } from "../../config/sessions/types.js";

import type { OpenClawConfig } from "../../config/types.openclaw.js";

import { callGateway } from "../../gateway/call.js";

import { deriveSessionTitle } from "../../gateway/session-utils.js";

import {

deriveSessionTitle,

readSessionTitleFieldsFromTranscriptAsync,

} from "../../gateway/session-utils.js";

import { resolveAgentIdFromSessionKey } from "../../routing/session-key.js";

import { normalizeOptionalLowercaseString, readStringValue } from "../../shared/string-coerce.js";

import {

type GatewayCaller = typeof callGateway;

const SESSIONS_LIST_TRANSCRIPT_FIELD_ROWS = 100;

function readSessionRunStatus(value: unknown): SessionRunStatus | undefined {

return value === "running" ||

value === "done" ||

const includeDerivedTitles = params.includeDerivedTitles === true;

const includeLastMessage = params.includeLastMessage === true;

const gatewayCall = opts?.callGateway ?? callGateway;

const a2aPolicy = createAgentToAgentPolicy(cfg);

const hydrateTranscriptFieldsAfterFiltering = includeDerivedTitles || includeLastMessage;

const list = await gatewayCall<{ sessions: Array<SessionListRow>; path: string }>({

method: "sessions.list",

label,

agentId,

search,

includeDerivedTitles,

includeLastMessage,

includeDerivedTitles: false,

includeLastMessage: false,

includeGlobal: !restrictToSpawned,

includeUnknown: !restrictToSpawned,

spawnedBy: restrictToSpawned ? effectiveRequesterKey : undefined,

const sessions = Array.isArray(list?.sessions) ? list.sessions : [];

const storePath = typeof list?.path === "string" ? list.path : undefined;

const a2aPolicy = createAgentToAgentPolicy(cfg);

const visibilityGuard = await createSessionVisibilityGuard({

action: "list",

requesterSessionKey: effectiveRequesterKey,

});

const rows: SessionListRow[] = [];

const historyTargets: Array<{ row: SessionListRow; resolvedKey: string }> = [];

const titleTargets: Array<{

row: SessionListRow;

titleEntry: SessionEntry;

sessionId: string;

sessionFile?: string;

agentId: string;

}> = [];

for (const entry of sessions) {

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

lastAccountId,

transcriptPath,

};

if (sessionId && includeDerivedTitles && !row.derivedTitle) {

row.derivedTitle = deriveSessionTitle(

{

if (

sessionId &&

hydrateTranscriptFieldsAfterFiltering &&

titleTargets.length < SESSIONS_LIST_TRANSCRIPT_FIELD_ROWS

) {

titleTargets.push({

row,

titleEntry: {

sessionId,

displayName: row.displayName,

label: row.label,

subject: readStringValue((entry as { subject?: unknown }).subject),

updatedAt: typeof row.updatedAt === "number" ? row.updatedAt : 0,

},

undefined,

);

sessionId,

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

agentId: resolvedAgentId,

});

}

if (messageLimit > 0) {

const resolvedKey = resolveInternalSessionKey({

rows.push(row);

}

if (titleTargets.length > 0) {

const maxConcurrent = Math.min(4, titleTargets.length);

let index = 0;

const worker = async () => {

while (true) {

const next = index;

index += 1;

if (next >= titleTargets.length) {

return;

}

const target = titleTargets[next];

const fields = await readSessionTitleFieldsFromTranscriptAsync(

target.sessionId,

storePath,

target.sessionFile,

target.agentId,

);

if (includeDerivedTitles && !target.row.derivedTitle) {

target.row.derivedTitle = deriveSessionTitle(

target.titleEntry,

fields.firstUserMessage,

);

}

if (includeLastMessage && fields.lastMessagePreview) {

target.row.lastMessagePreview = fields.lastMessagePreview;

}

}

};

await Promise.all(Array.from({ length: maxConcurrent }, () => worker()));

}

if (messageLimit > 0 && historyTargets.length > 0) {

const maxConcurrent = Math.min(4, historyTargets.length);

let index = 0;