import { r as createLazyRuntimeModule } from "./lazy-runtime-CgCh8H_K.js";
import { l as normalizeOptionalString } from "./string-coerce-CIXf7egm.js";
import { c as parseAgentSessionKey } from "./session-key-utils-dXMHZk48.js";
import { d as loadSessionEntry } from "./session-accessor.sqlite-entry-CoLie3L_.js";
import { n as parseSqliteSessionFileMarker } from "./legacy-sqlite-marker-COPKCuIN.js";
import "./session-accessor-Dwfzn6Ej.js";
import { t as listSessionEntriesCore } from "./session-accessor.entry-Bsl0TxF5.js";
import { i as markRuntimeCompactionDelegate } from "./compaction-watchdog-D-CcgAHX.js";
import { f as prepareMemoryPromptSection, i as getActivePreparedMemoryPromptSection, n as buildMemoryPromptSection } from "./memory-state-DsF5HJ_p.js";
import { t as resolvePreferredSessionKeyForSessionIdMatches } from "./session-id-resolution-DJEewvQl.js";
import path from "node:path";
import { normalizeStructuredPromptSection } from "@openclaw/ai/internal/shared";
//#region src/context-engine/delegate.ts
const loadCompactRuntime = createLazyRuntimeModule(() => import("./compact.runtime.js"));
function buildCompactionResultSessionTarget(params) {
	const sessionFile = normalizeOptionalString(params.sessionFile);
	const marker = parseSqliteSessionFileMarker(sessionFile);
	const targetAgentId = normalizeOptionalString(params.callerSessionTarget?.agentId);
	const targetSessionId = normalizeOptionalString(params.callerSessionTarget?.sessionId);
	const targetSessionKey = normalizeOptionalString(params.callerSessionTarget?.sessionKey);
	const targetStorePath = normalizeOptionalString(params.callerSessionTarget?.storePath);
	const requestedAgentId = normalizeOptionalString(params.agentId);
	const callerSessionId = normalizeOptionalString(params.callerSessionId);
	const requestedSessionKey = normalizeOptionalString(params.sessionKey);
	const requestedSessionKeyAgentId = parseAgentSessionKey(requestedSessionKey)?.agentId;
	if (requestedAgentId && targetAgentId && requestedAgentId !== targetAgentId || callerSessionId && targetSessionId && callerSessionId !== targetSessionId || requestedSessionKey && targetSessionKey && requestedSessionKey !== targetSessionKey || requestedSessionKeyAgentId && targetAgentId && requestedSessionKeyAgentId !== targetAgentId) throw new Error("Context-engine successor target conflicts with the caller session identity");
	const suppliedAgentId = targetAgentId ?? requestedAgentId;
	const suppliedSessionId = normalizeOptionalString(params.sessionId);
	const suppliedSessionKey = targetSessionKey ?? requestedSessionKey;
	const suppliedSessionKeyAgentId = parseAgentSessionKey(suppliedSessionKey)?.agentId;
	const callerAgentId = suppliedAgentId ?? suppliedSessionKeyAgentId;
	if (callerAgentId && marker && marker.agentId !== callerAgentId || targetStorePath && marker && path.resolve(marker.storePath) !== path.resolve(targetStorePath)) throw new Error("Context-engine successor target conflicts with the caller session identity");
	if (marker && suppliedSessionId && marker.sessionId !== suppliedSessionId) throw new Error("Context-engine successor identity is inconsistent");
	const candidateEntry = marker && suppliedSessionKey ? loadSessionEntry({
		agentId: marker.agentId,
		sessionKey: suppliedSessionKey,
		storePath: marker.storePath
	}) : void 0;
	const markerMatches = marker ? listSessionEntriesCore({
		agentId: marker.agentId,
		storePath: marker.storePath
	}).filter(({ entry }) => entry.sessionId === marker.sessionId) : [];
	const preferredMarkerSessionKey = marker ? resolvePreferredSessionKeyForSessionIdMatches(markerMatches.map(({ sessionKey, entry }) => [sessionKey, entry]), marker.sessionId) : void 0;
	const callerAuthorizedMarkerKey = Boolean(suppliedSessionKey && (!candidateEntry || candidateEntry.sessionId === callerSessionId));
	const markerSessionKey = marker ? callerAuthorizedMarkerKey || candidateEntry?.sessionId === marker.sessionId ? suppliedSessionKey : preferredMarkerSessionKey ?? (candidateEntry ? void 0 : suppliedSessionKey) : void 0;
	if (sessionFile && !marker) throw new Error("Legacy context-engine file successors are unsupported");
	if (marker && !markerSessionKey) throw new Error("Legacy context-engine successor identity is ambiguous");
	if (marker && suppliedSessionKey && (candidateEntry && candidateEntry.sessionId !== marker.sessionId && !callerAuthorizedMarkerKey || !candidateEntry && markerMatches.length > 0)) throw new Error("Legacy context-engine successor session key is inconsistent");
	if (marker && suppliedSessionKeyAgentId && suppliedSessionKeyAgentId !== marker.agentId) throw new Error("Legacy context-engine successor identity is inconsistent");
	const sessionId = marker?.sessionId ?? suppliedSessionId ?? targetSessionId ?? callerSessionId;
	if (!sessionId) return;
	const agentId = marker?.agentId ?? callerAgentId;
	const sessionKey = marker ? markerSessionKey : suppliedSessionKey;
	const sessionKeyAgentId = parseAgentSessionKey(sessionKey)?.agentId;
	if (sessionKeyAgentId && agentId && sessionKeyAgentId !== agentId) throw new Error("Context-engine successor session key conflicts with its agent identity");
	const storePath = marker?.storePath ?? targetStorePath;
	return {
		...agentId ? { agentId } : {},
		sessionId,
		...sessionKey ? { sessionKey } : {},
		...storePath ? { storePath } : {},
		...params.callerSessionTarget?.threadId !== void 0 ? { threadId: params.callerSessionTarget.threadId } : {}
	};
}
/**
* Delegate a context-engine compaction request to OpenClaw's built-in runtime compaction path.
*
* This is the same bridge used by the legacy context engine. Third-party
* engines can call it from their own `compact()` implementations when they do
* not own the compaction algorithm but still need `/compact` and overflow
* recovery to use the stock runtime behavior.
*
* Note: `compactionTarget` is part of the public `compact()` contract, but the
* built-in runtime compaction path does not expose that knob. This helper
* ignores it to preserve legacy behavior; engines that need target-specific
* compaction should implement their own `compact()` algorithm.
*/
async function delegateCompactionToRuntime(params) {
	const { compactEmbeddedAgentSessionOnDemand } = await loadCompactRuntime();
	const runtimeContext = params.runtimeContext ?? {};
	const { sessionFile: _legacySessionFile, ...runtimeContextParams } = runtimeContext;
	const sessionTarget = params.sessionTarget ?? runtimeContext.sessionTarget;
	const agentId = params.agentId ?? runtimeContext.agentId;
	const sessionKey = params.sessionKey ?? runtimeContext.sessionKey;
	const currentTokenCount = params.currentTokenCount ?? (typeof runtimeContext.currentTokenCount === "number" && Number.isFinite(runtimeContext.currentTokenCount) && runtimeContext.currentTokenCount > 0 ? Math.floor(runtimeContext.currentTokenCount) : void 0);
	const result = await compactEmbeddedAgentSessionOnDemand({
		...runtimeContextParams,
		contextEngineRuntimeContext: runtimeContext,
		...agentId ? { agentId } : {},
		sessionId: params.sessionId,
		...sessionKey ? { sessionKey } : {},
		...sessionTarget ? { sessionTarget } : {},
		tokenBudget: params.tokenBudget,
		...currentTokenCount !== void 0 ? { currentTokenCount } : {},
		force: params.force,
		customInstructions: params.customInstructions,
		abortSignal: params.abortSignal,
		workspaceDir: typeof runtimeContext.workspaceDir === "string" ? runtimeContext.workspaceDir : process.cwd()
	});
	const resultSessionTarget = result.result ? buildCompactionResultSessionTarget({
		agentId,
		callerSessionId: params.sessionId,
		callerSessionTarget: sessionTarget,
		sessionFile: result.result.sessionFile,
		sessionId: result.result.sessionId,
		sessionKey
	}) : void 0;
	return {
		ok: result.ok,
		compacted: result.compacted,
		reason: result.reason,
		result: result.result ? {
			summary: result.result.summary,
			firstKeptEntryId: result.result.firstKeptEntryId,
			tokensBefore: result.result.tokensBefore,
			tokensAfter: result.result.tokensAfter,
			details: result.result.details,
			...result.result.sessionId ? { sessionId: resultSessionTarget?.sessionId ?? result.result.sessionId } : {},
			...resultSessionTarget ? { sessionTarget: resultSessionTarget } : {}
		} : void 0
	};
}
markRuntimeCompactionDelegate(delegateCompactionToRuntime);
/**
* Build a context-engine-ready systemPromptAddition from the active memory
* plugin prompt path. This lets non-legacy engines explicitly opt into the
* same memory/wiki guidance that the legacy engine gets via system prompt
* assembly, without reimplementing memory prompt formatting.
*/
function renderMemorySystemPromptAddition(params, prepared) {
	const lines = buildMemoryPromptSection(params, prepared);
	if (lines.length === 0) return;
	return normalizeStructuredPromptSection(lines.join("\n")) || void 0;
}
function buildMemorySystemPromptAddition(params) {
	const prepared = getActivePreparedMemoryPromptSection();
	if (!prepared) return renderMemorySystemPromptAddition(params);
	return renderMemorySystemPromptAddition({
		availableTools: params.availableTools,
		citationsMode: params.citationsMode ?? prepared.context.citationsMode,
		agentId: params.agentId ?? prepared.context.agentId,
		agentSessionKey: params.agentSessionKey ?? prepared.context.agentSessionKey,
		sandboxed: params.sandboxed ?? prepared.context.sandboxed
	}, prepared);
}
/** Prepare memory state asynchronously, then render it without prompt-path I/O. */
async function prepareMemorySystemPromptAddition(params) {
	return renderMemorySystemPromptAddition(params, await prepareMemoryPromptSection(params));
}
//#endregion
export { delegateCompactionToRuntime as n, prepareMemorySystemPromptAddition as r, buildMemorySystemPromptAddition as t };
