import { resolveAgentModelFallbackValues } from "../../config/model-input.js";

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

import {

captureCompactionCheckpointSnapshotAsync,

cleanupCompactionCheckpointSnapshot,

persistSessionCompactionCheckpoint,

createFileBackedCompactionCheckpointStore,

readSessionLeafStateFromTranscriptAsync,

resolveCompactionCheckpointTranscriptPosition,

resolveSessionCompactionCheckpointReason,

import { resolveAgentPromptSurfaceForSessionKey } from "../prompt-surface.js";

import { applyPreparedRuntimeAuthToModel } from "../provider-request-config.js";

import { registerProviderStreamForModel } from "../provider-stream.js";

import {

applyAgentRunSessionTargetIdentity,

resolveAgentRunSessionTarget,

} from "../run-session-target.js";

import { collectRuntimeChannelCapabilities } from "../runtime-capabilities.js";

import { buildAgentRuntimePlan } from "../runtime-plan/build.js";

import type { AgentRuntimePlan } from "../runtime-plan/types.js";

} from "./compact-reasons.js";

import type {

CompactEmbeddedAgentSessionParams,

CompactEmbeddedAgentSessionRuntimeParams,

CompactionMessageMetrics,

} from "./compact.types.js";

import { dedupeDuplicateUserMessagesForCompaction } from "./compaction-duplicate-user-messages.js";

import { flushPendingToolResultsAfterIdle } from "./wait-for-idle-before-flush.js";

export type { CompactEmbeddedAgentSessionParams } from "./compact.types.js";

const compactionCheckpointStore = createFileBackedCompactionCheckpointStore();

type CompactEmbeddedAgentSessionParamsWithSessionFile = CompactEmbeddedAgentSessionRuntimeParams & {

sessionFile: string;

};

function hasRealConversationContent(

msg: AgentMessage,

messages: AgentMessage[],

* Use this when already inside a session/global lane to avoid deadlocks.

*/

export async function compactEmbeddedAgentSessionDirect(

params: CompactEmbeddedAgentSessionParams,

paramsInput: CompactEmbeddedAgentSessionRuntimeParams,

): Promise<EmbeddedAgentCompactResult> {

const paramsBase = applyAgentRunSessionTargetIdentity(paramsInput);

const runSessionTarget = await resolveAgentRunSessionTarget(paramsBase);

const params: CompactEmbeddedAgentSessionParamsWithSessionFile = {

...paramsBase,

agentId: paramsBase.agentId ?? runSessionTarget.agentId,

sessionId: runSessionTarget.sessionId,

sessionKey: paramsBase.sessionKey ?? runSessionTarget.sessionKey,

sessionFile: runSessionTarget.sessionFile,

};

if (hasExplicitCompactionModel(params) || !hasCompactionModelFallbackCandidates(params)) {

return await compactEmbeddedAgentSessionDirectOnce(params);

}

}

async function compactEmbeddedAgentSessionDirectOnce(

params: CompactEmbeddedAgentSessionParams,

params: CompactEmbeddedAgentSessionParamsWithSessionFile,

): Promise<EmbeddedAgentCompactResult> {

const startedAt = Date.now();

const diagId = params.diagId?.trim() || createCompactionDiagId();

: undefined,

allowedToolNames,

});

checkpointSnapshot = await captureCompactionCheckpointSnapshotAsync({

checkpointSnapshot = await compactionCheckpointStore.captureSnapshot({

sessionManager,

sessionFile: params.sessionFile,

});

preferredLeafId: activePostLeafId,

transcriptState,

});

const storedCheckpoint = await persistSessionCompactionCheckpoint({

const storedCheckpoint = await compactionCheckpointStore.persistCheckpoint({

cfg: params.config,

sessionKey: params.sessionKey,

sessionId: activeSessionId,

return fail(reason, err);

} finally {

if (!checkpointSnapshotRetained) {

await cleanupCompactionCheckpointSnapshot(checkpointSnapshot);

await compactionCheckpointStore.cleanupSnapshot(checkpointSnapshot);

}

restoreSkillEnv?.();

}