transcriptUsageMaxBytes?: number;

storeChildSessionsByKey?: Map<string, string[]>;

rowContext?: SessionListRowContext;

skipTranscriptUsageFallback?: boolean;

lightweightListRow?: boolean;

}): GatewaySessionRow {

const { cfg, storePath, store, key, entry } = params;

const lightweight = params.lightweightListRow === true;

const skipTranscriptUsage = params.skipTranscriptUsageFallback === true;

const now = params.now ?? Date.now();

const updatedAt = entry?.updatedAt ?? null;

const parsed = parseGroupKey(key);

entry,

}) === undefined;

const transcriptUsage =

needsTranscriptTotalTokens || needsTranscriptContextTokens || needsTranscriptEstimatedCostUsd

!skipTranscriptUsage &&

(needsTranscriptTotalTokens || needsTranscriptContextTokens || needsTranscriptEstimatedCostUsd)

? resolveTranscriptUsageFallback({

cfg,

key,

const latestCompactionCheckpoint = buildCompactionCheckpointPreview(

resolveLatestCompactionCheckpoint(entry),

);

const agentRuntime = resolveAgentRuntimeMetadata(cfg, sessionAgentId);

const agentRuntime = lightweight ? undefined : resolveAgentRuntimeMetadata(cfg, sessionAgentId);

const selectedOrRuntimeModelProvider = selectedModel?.provider ?? modelProvider;

const selectedOrRuntimeModel = selectedModel?.model ?? model;

const rowModelIdentity = resolveSessionDisplayModelIdentityRef({

cfg,

agentId: sessionAgentId,

provider: selectedOrRuntimeModelProvider,

model: selectedOrRuntimeModel,

});

const rowModelIdentity = lightweight

? { provider: selectedOrRuntimeModelProvider, model: selectedOrRuntimeModel }

: resolveSessionDisplayModelIdentityRef({

cfg,

agentId: sessionAgentId,

provider: selectedOrRuntimeModelProvider,

model: selectedOrRuntimeModel,

});

const rowModelProvider = rowModelIdentity.provider;

const rowModel = rowModelIdentity.model;

const estimatedCostUsd =

resolveEstimatedSessionCostUsd({

cfg,

provider: rowModelProvider,

model: rowModel,

entry,

}) ?? resolveNonNegativeNumber(transcriptUsage?.estimatedCostUsd);

const contextTokens =

resolvePositiveNumber(entry?.contextTokens) ??

resolvePositiveNumber(transcriptUsage?.contextTokens) ??

resolvePositiveNumber(

resolveContextTokensForModel({

const estimatedCostUsd = lightweight

? resolveNonNegativeNumber(entry?.estimatedCostUsd)

: resolveEstimatedSessionCostUsd({

cfg,

provider: rowModelProvider,

model: rowModel,

// Gateway/session listing is read-only; don't start async model discovery.

allowAsyncLoad: false,

}),

);

entry,

}) ?? resolveNonNegativeNumber(transcriptUsage?.estimatedCostUsd);

const contextTokens = lightweight

? resolvePositiveNumber(entry?.contextTokens)

: resolvePositiveNumber(entry?.contextTokens) ??

resolvePositiveNumber(transcriptUsage?.contextTokens) ??

resolvePositiveNumber(

resolveContextTokensForModel({

cfg,

provider: rowModelProvider,

model: rowModel,

allowAsyncLoad: false,

}),

);

let derivedTitle: string | undefined;

let lastMessagePreview: string | undefined;

const thinkingProvider = rowModelProvider ?? DEFAULT_PROVIDER;

const thinkingModel = rowModel ?? DEFAULT_MODEL;

const thinkingLevels = listThinkingLevelOptions(

thinkingProvider,

thinkingModel,

params.modelCatalog,

);

const pluginExtensions = entry

? projectPluginSessionExtensionsSync({ sessionKey: key, entry })

: [];

const thinkingLevels = lightweight

? []

: listThinkingLevelOptions(thinkingProvider, thinkingModel, params.modelCatalog);

const pluginExtensions =

!lightweight && entry ? projectPluginSessionExtensionsSync({ sessionKey: key, entry }) : [];

return {

key,

thinkingLevel: entry?.thinkingLevel,

thinkingLevels,

thinkingOptions: thinkingLevels.map((level) => level.label),

thinkingDefault: resolveGatewaySessionThinkingDefault({

cfg,

provider: thinkingProvider,

model: thinkingModel,

agentId: sessionAgentId,

modelCatalog: params.modelCatalog,

}),

thinkingDefault: lightweight

? entry?.thinkingLevel

: resolveGatewaySessionThinkingDefault({

cfg,

provider: thinkingProvider,

model: thinkingModel,

agentId: sessionAgentId,

modelCatalog: params.modelCatalog,

}),

fastMode: entry?.fastMode,

verboseLevel: entry?.verboseLevel,

traceLevel: entry?.traceLevel,

transcriptUsageMaxBytes: sessionListTranscriptUsageMaxBytes,

storeChildSessionsByKey: getRowContext().storeChildSessionsByKey,

rowContext: getRowContext(),

skipTranscriptUsageFallback: true,

lightweightListRow: true,

});

if (

entry?.sessionId &&