openclaw/dist/entry-freshness-w7a3CGPV.mjs

Multi-channel AI gateway with extensible messaging integrations

import { l as normalizeOptionalString } from "./string-coerce-1VuiLaaR.mjs";
import { l as resolveAgentIdFromSessionKey } from "./session-key-DY3MOX4N.mjs";
import { c as resolveSessionStorePathCore } from "./paths-Bonddxfk.mjs";
import { r as resolveSqliteSessionKey } from "./session-accessor.sqlite-scope-helpers-CfDTAEsL.mjs";
import { r as getCliSessionBinding } from "./cli-session-binding-Dx1VbkI8.mjs";
import { s as isNativeSessionEntryRead } from "./session-entry-read-ordered-D14zdHVq.mjs";
import { s as loadSessionEntryReadOnly } from "./session-accessor.sqlite-entry-DLa7_9ui.mjs";
import "./session-accessor-C3ljJ974.mjs";
import { c as withSessionEntriesFromStoresInWorker } from "./session-entry-read-runtime-BdnQjoL6.mjs";
import { a as resolveSessionResetPolicy, i as evaluateSessionFreshness } from "./reset-SWON9U-K.mjs";
import { n as resolveSessionLifecycleTimestamps } from "./lifecycle-BJGMGqxC.mjs";
//#region src/config/sessions/entry-freshness.ts
function hasProviderOwnedSession(entry) {
	const provider = normalizeOptionalString(entry?.providerOverride ?? entry?.modelProvider);
	return Boolean(provider && getCliSessionBinding(entry, provider));
}
function resolveFreshnessScope(params) {
	const agentId = params.agentId ?? resolveAgentIdFromSessionKey(params.sessionKey, params.defaultAgentId);
	const sessionCfg = params.sessionCfg;
	const storePath = params.storePath ?? resolveSessionStorePathCore(sessionCfg?.store, {
		agentId,
		env: params.env
	});
	return {
		...params,
		agentId,
		storePath
	};
}
/** @deprecated Runtime callers should await resolveSessionEntryResetFreshnessAsync. */
function resolveSessionEntryResetFreshness(params) {
	const scope = resolveFreshnessScope(params);
	const entry = loadSessionEntryReadOnly(scope);
	return resolvePreparedSessionEntryResetFreshness(params, entry, resolveSessionLifecycleTimestamps({
		...scope,
		entry
	}));
}
/** Entry and transcript fallback belong to the same retained worker snapshot. */
async function resolveSessionEntryResetFreshnessAsync(params) {
	const scope = resolveFreshnessScope(params);
	if (isNativeSessionEntryRead(scope, scope.agentId)) return resolveSessionEntryResetFreshness(scope);
	const sessionKey = resolveSqliteSessionKey(scope.sessionKey, scope.agentId);
	return withSessionEntriesFromStoresInWorker([{
		...scope,
		sessionKeys: [sessionKey],
		lifecycleSessionKey: sessionKey
	}], ([read]) => {
		read.assertCurrent();
		return resolvePreparedSessionEntryResetFreshness(params, read.result.entries[0]?.entry, read.result.lifecycleTimestamps);
	}, { ordered: true });
}
/** Consume entry and lifecycle facts from one retained read without opening another snapshot. */
function resolvePreparedSessionEntryResetFreshness(params, entry, lifecycleTimestamps) {
	const resetType = params.resetType;
	const resetPolicy = resolveSessionResetPolicy({
		sessionCfg: params.sessionCfg,
		resetType,
		resetOverride: params.resetOverride
	});
	const base = {
		lifecycleTimestamps,
		resetPolicy,
		resetType
	};
	if (!entry) return {
		state: "missing",
		entry: void 0,
		freshness: void 0,
		...base
	};
	const freshness = resetPolicy.configured !== true && hasProviderOwnedSession(entry) ? { fresh: true } : evaluateSessionFreshness({
		updatedAt: entry.updatedAt,
		sessionStartedAt: lifecycleTimestamps.sessionStartedAt,
		lastInteractionAt: lifecycleTimestamps.lastInteractionAt,
		now: params.now ?? Date.now(),
		policy: resetPolicy
	});
	return {
		state: freshness.fresh ? "fresh" : "stale",
		entry,
		freshness,
		...base
	};
}
//#endregion
export { resolveSessionEntryResetFreshnessAsync as i, resolvePreparedSessionEntryResetFreshness as n, resolveSessionEntryResetFreshness as r, hasProviderOwnedSession as t };