normalizeOptionalLowercaseString,

} from "../shared/string-coerce.js";

import { normalizeSessionDeliveryFields } from "../utils/delivery-context.shared.js";

import type { ModelCostConfig } from "../utils/usage-format.js";

import { estimateUsageCost, resolveModelCostConfig } from "../utils/usage-format.js";

import {

resolveSessionStoreAgentId,

};

}

function resolveModelCostConfigCached(

provider: string | undefined,

model: string | undefined,

cfg: OpenClawConfig,

rowContext?: SessionListRowContext,

): ModelCostConfig | undefined {

if (!rowContext) {

return resolveModelCostConfig({ provider, model, config: cfg });

}

const key = createSessionRowModelCacheKey(provider, model);

if (rowContext.modelCostConfigByModelRef.has(key)) {

return rowContext.modelCostConfigByModelRef.get(key);

}

const value = resolveModelCostConfig({ provider, model, config: cfg });

rowContext.modelCostConfigByModelRef.set(key, value);

return value;

}

function resolveEstimatedSessionCostUsd(params: {

cfg: OpenClawConfig;

provider?: string;

"estimatedCostUsd" | "inputTokens" | "outputTokens" | "cacheRead" | "cacheWrite"

>;

explicitCostUsd?: number;

rowContext?: SessionListRowContext;

}): number | undefined {

const explicitCostUsd = resolveNonNegativeNumber(

params.explicitCostUsd ?? params.entry?.estimatedCostUsd,

) {

return undefined;

}

const cost = resolveModelCostConfig({

provider: params.provider,

model: params.model,

config: params.cfg,

});

const cost = resolveModelCostConfigCached(

params.provider,

params.model,

params.cfg,

params.rowContext,

);

if (!cost) {

return undefined;

}

subagentRuns: ReturnType<typeof buildSubagentRunReadIndex>;

storeChildSessionsByKey: Map<string, string[]>;

selectedModelByOverrideRef: Map<string, ReturnType<typeof resolveSessionModelRef>>;

// Per-list memoization for deterministic resolvers that scale linearly with

// session count but only depend on (provider, model[, agentId]). Sessions

// in a single list typically share a small set of those tuples, so caching

// here collapses the work to O(unique tuples) per call.

thinkingMetadataByModelRef: Map<

string,

{

levels: ReturnType<typeof listThinkingLevelOptions>;

defaultLevel: ReturnType<typeof resolveGatewaySessionThinkingDefault>;

}

>;

displayModelIdentityByKey: Map<string, { provider?: string; model?: string }>;

modelCostConfigByModelRef: Map<string, ModelCostConfig | undefined>;

};

function resolveRuntimeChildSessionKeys(

storeChildSessionsByKey: buildStoreChildSessionIndex(params.store, params.now, subagentRuns),

selectedModelByOverrideRef: new Map(),

thinkingMetadataByModelRef: new Map(),

displayModelIdentityByKey: new Map(),

modelCostConfigByModelRef: new Map(),

};

}

fallbackProvider?: string;

fallbackModel?: string;

maxTranscriptBytes?: number;

rowContext?: SessionListRowContext;

}): {

estimatedCostUsd?: number;

totalTokens?: number;

cacheRead: snapshot.cacheRead,

cacheWrite: snapshot.cacheWrite,

},

rowContext: params.rowContext,

});

return {

modelProvider,

return { provider: resolved.provider, model: resolved.model };

}

function resolveSessionDisplayModelIdentityRefCached(params: {

cfg: OpenClawConfig;

agentId: string;

provider?: string;

model?: string;

rowContext?: SessionListRowContext;

}): { provider?: string; model?: string } {

const ctx = params.rowContext;

if (!ctx) {

return resolveSessionDisplayModelIdentityRef(params);

}

const key = `${params.agentId}\u0000${createSessionRowModelCacheKey(

params.provider,

params.model,

)}`;

const cached = ctx.displayModelIdentityByKey.get(key);

if (cached) {

return cached;

}

const value = resolveSessionDisplayModelIdentityRef(params);

ctx.displayModelIdentityByKey.set(key, value);

return value;

}

export function resolveSessionDisplayModelIdentityRef(params: {

cfg: OpenClawConfig;

agentId: string;

provider: resolvedModel.provider,

model: resolvedModel.model ?? DEFAULT_MODEL,

entry,

rowContext,

}) === undefined;

const transcriptUsage =

!skipTranscriptUsage &&

fallbackProvider: resolvedModel.provider,

fallbackModel: resolvedModel.model ?? DEFAULT_MODEL,

maxTranscriptBytes: params.transcriptUsageMaxBytes,

rowContext: params.rowContext,

})

: null;

const preferLiveSubagentModelIdentity =

const selectedOrRuntimeModel = selectedModel?.model ?? model;

const rowModelIdentity = lightweight

? { provider: selectedOrRuntimeModelProvider, model: selectedOrRuntimeModel }

: resolveSessionDisplayModelIdentityRef({

: resolveSessionDisplayModelIdentityRefCached({

cfg,

agentId: sessionAgentId,

provider: selectedOrRuntimeModelProvider,

model: selectedOrRuntimeModel,

rowContext: params.rowContext,

});

const rowModelProvider = rowModelIdentity.provider;

const rowModel = rowModelIdentity.model;

provider: rowModelProvider,

model: rowModel,

entry,

rowContext: params.rowContext,

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

const contextTokens = lightweight

? resolvePositiveNumber(entry?.contextTokens)

abortedLastRun: entry?.abortedLastRun,

thinkingLevel: entry?.thinkingLevel,

thinkingLevels,

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

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

thinkingDefault,

fastMode: entry?.fastMode,

verboseLevel: entry?.verboseLevel,