import type { SessionEntry } from "../../config/sessions/types.js";

import { createLazyImportLoader } from "../../shared/lazy-promise.js";

import { setAbortMemory } from "./abort-primitives.js";

import type { ReplySessionEntryHandle } from "./session-entry-handle.js";

const sessionAccessorRuntimeLoader = createLazyImportLoader(

() => import("../../config/sessions/session-accessor.js"),

baseBody: string;

abortedLastRun: boolean;

sessionEntry?: SessionEntry;

sessionEntryHandle?: ReplySessionEntryHandle;

sessionStore?: Record<string, SessionEntry>;

sessionKey?: string;

storePath?: string;

if (abortedHint) {

prefixedBodyBase = `${abortedHint}\n\n${prefixedBodyBase}`;

// The abort hint is one-shot; clear durable state once it is added.

if (params.sessionEntry && params.sessionStore && params.sessionKey) {

const sessionEntry = params.sessionEntryHandle?.getCurrent() ?? params.sessionEntry;

if (sessionEntry && params.sessionEntryHandle && params.sessionKey) {

const updatedAt = Date.now();

params.sessionEntry.abortedLastRun = false;

params.sessionEntry.updatedAt = updatedAt;

params.sessionStore[params.sessionKey] = params.sessionEntry;

params.sessionEntryHandle.patchCurrent({

abortedLastRun: false,

updatedAt,

});

if (params.storePath) {

const sessionKey = params.sessionKey;

const { patchSessionEntry } = await loadSessionAccessorRuntime();

abortedLastRun: false,

updatedAt,

}),

{ fallbackEntry: params.sessionEntry },

{ fallbackEntry: params.sessionEntryHandle.getCurrent() ?? sessionEntry },

);

}

} else if (sessionEntry && params.sessionStore && params.sessionKey) {

const updatedAt = Date.now();

sessionEntry.abortedLastRun = false;

sessionEntry.updatedAt = updatedAt;

params.sessionStore[params.sessionKey] = sessionEntry;

if (params.storePath) {

const sessionKey = params.sessionKey;

const { patchSessionEntry } = await loadSessionAccessorRuntime();

await patchSessionEntry(

{

storePath: params.storePath,

sessionKey,

},

() => ({

abortedLastRun: false,

updatedAt,

}),

{ fallbackEntry: sessionEntry },

);

}

} else if (params.abortKey) {

import { parseSoftResetCommand } from "./commands-reset-mode.js";

import type { CommandContext } from "./commands-types.js";

import { stripMentions, stripStructuralPrefixes } from "./mentions.js";

import { createReplySessionEntryHandle } from "./session-entry-handle.js";

import type { SessionInitResult } from "./session.js";

const COMPLETE_REPLY_CONFIG_SYMBOL = Symbol.for("openclaw.reply.complete-config");

: {}),

};

sessionStore[sessionKey] = sessionEntry;

const sessionEntryHandle = createReplySessionEntryHandle({

sessionEntry,

sessionKey,

sessionStore,

});

const sessionCtx: TemplateContext = {

...ctx,

SessionKey: sessionKey,

return {

sessionCtx,

sessionEntry,

sessionEntryHandle,

sessionStore,

sessionKey,

sessionId,

import { resolveReplyToMode } from "./reply-threading.js";

import { resolveRoutedDeliveryThreadId } from "./routed-delivery-thread.js";

import { resolveRuntimePolicySessionKey } from "./runtime-policy-session-key.js";

import type { ReplySessionEntryHandle } from "./session-entry-handle.js";

import { resolveBareSessionResetPromptState } from "./session-reset-prompt.js";

import { resolveBareResetBootstrapFileAccess } from "./session-reset-prompt.js";

import { drainFormattedSystemEvents } from "./session-system-events.js";

resetTriggered: boolean;

systemSent: boolean;

sessionEntry?: SessionEntry;

sessionEntryHandle?: ReplySessionEntryHandle;

sessionStore?: Record<string, SessionEntry>;

sessionKey: string;

sessionId?: string;

sessionId,

storePath,

workspaceDir,

sessionEntryHandle,

sessionStore,

} = params;

const runtimePolicySessionKey = resolveRuntimePolicySessionKey({

baseBody: effectiveBaseBody,

abortedLastRun,

sessionEntry,

sessionEntryHandle,

sessionStore,

sessionKey,

storePath,

abortKey: command.abortKey,

});

sessionEntry = sessionEntryHandle?.getCurrent() ?? sessionEntry;

const isGroupSession = sessionEntry?.chatType === "group" || sessionEntry?.chatType === "channel";

const isMainSession = !isGroupSession && sessionKey === normalizeMainKey(sessionCfg?.mainKey);

// Extract first-token think hint from the user body BEFORE prepending system events.

const { ensureSkillSnapshot } = await loadSessionUpdatesRuntime();

return await ensureSkillSnapshot({

sessionEntry,

sessionEntryHandle,

sessionStore,

sessionKey,

storePath,

});

});

sessionEntry = skillResult.sessionEntry ?? sessionEntry;

if (sessionEntry) {

sessionEntryHandle?.replaceCurrent(sessionEntry);

}

const skillsSnapshot = skillResult.skillsSnapshot;

let {

prefixedCommandBody,

const {

sessionCtx,

sessionEntry,

sessionEntryHandle,

previousSessionEntry,

sessionStore,

sessionKey,

sessionEntry.pendingFinalDeliveryAttemptCount = undefined;

sessionEntry.pendingFinalDeliveryLastError = undefined;

sessionEntry.pendingFinalDeliveryContext = undefined;

sessionEntryHandle.replaceCurrent(sessionEntry);

if (sessionKey && sessionStore) {

sessionStore[sessionKey] = sessionEntry;

}

sessionCtx,

ctx: finalized,

sessionEntry,

sessionEntryHandle,

sessionStore,

sessionKey,

storePath,

resetTriggered,

systemSent,

sessionEntry,

sessionEntryHandle,

sessionStore,

sessionKey,

sessionId,

export function maybeRetireLegacyMainDeliveryRoute(params: {

sessionCfg: { dmScope?: string } | undefined;

sessionKey: string;

sessionStore: Record<string, SessionEntry>;

legacyMain?: SessionEntry;

agentId: string;

mainKey: string;

isGroup: boolean;

if (params.sessionKey === canonicalMainSessionKey) {

return undefined;

}

const legacyMain = params.sessionStore[canonicalMainSessionKey];

const legacyMain = params.legacyMain;

if (!legacyMain) {

return undefined;

}

// Narrow mutable handle for the active reply session entry.

import type { SessionEntry } from "../../config/sessions.js";

export type ReplySessionEntryHandle = {

get(sessionKey: string): SessionEntry | undefined;

getCurrent(): SessionEntry | undefined;

patchCurrent(patch: Partial<SessionEntry>): SessionEntry | undefined;

replaceCurrent(entry: SessionEntry): void;

set(sessionKey: string, entry: SessionEntry): void;

toCompatSessionStore(): Record<string, SessionEntry>;

};

export function createReplySessionEntryHandle(params: {

sessionEntry: SessionEntry;

sessionKey: string;

sessionStore?: Record<string, SessionEntry>;

}): ReplySessionEntryHandle {

const entries = params.sessionStore ?? { [params.sessionKey]: params.sessionEntry };

let currentEntry = params.sessionEntry;

entries[params.sessionKey] = currentEntry;

return {

get: (sessionKey) => entries[sessionKey],

getCurrent: () => currentEntry,

patchCurrent: (patch) => {

currentEntry = { ...currentEntry, ...patch };

entries[params.sessionKey] = currentEntry;

return currentEntry;

},

replaceCurrent: (entry) => {

currentEntry = entry;

entries[params.sessionKey] = entry;

},

set: (sessionKey, entry) => {

entries[sessionKey] = entry;

if (sessionKey === params.sessionKey) {

currentEntry = entry;

}

},

toCompatSessionStore: () => entries,

};

}

// Prepares parent-context fork metadata for guarded reply session initialization.

import path from "node:path";

import type { SessionEntry } from "../../config/sessions.js";

import { forkSessionFromParent, resolveParentForkDecision } from "./session-fork.js";

export async function prepareReplySessionParentFork(params: {

agentId: string;

alreadyForked: boolean;

parentSessionKey?: string;

readEntry: (sessionKey: string) => SessionEntry | undefined;

sessionEntry: SessionEntry;

sessionKey: string;

storePath: string;

warn: (message: string) => void;

}): Promise<SessionEntry> {

if (

!params.parentSessionKey ||

params.parentSessionKey === params.sessionKey ||

params.alreadyForked

) {

return params.sessionEntry;

}

const parentEntry = params.readEntry(params.parentSessionKey);

if (!parentEntry?.sessionId) {

return params.sessionEntry;

}

const decision = await resolveParentForkDecision({

parentEntry,

agentId: params.agentId,

storePath: params.storePath,

});

if (decision.status === "skip") {

// The parent branch is too large to inherit usefully. Start fresh and

// mark as handled so the thread does not retry this decision every turn.

params.warn(

`skipping parent fork (parent too large): parentKey=${params.parentSessionKey} → sessionKey=${params.sessionKey} ` +

`parentTokens=${decision.parentTokens} maxTokens=${decision.maxTokens}`,

);

return { ...params.sessionEntry, forkedFromParent: true };

}

const fork = await forkSessionFromParent({

parentEntry,

agentId: params.agentId,

sessionsDir: path.dirname(params.storePath),

});

if (!fork) {

return params.sessionEntry;

}

params.warn(

`forking from parent session: parentKey=${params.parentSessionKey} → sessionKey=${params.sessionKey} ` +

`parentTokens=${decision.parentTokens ?? "unknown"}`,

);

params.warn(`forked session created: file=${fork.sessionFile}`);

return {

...params.sessionEntry,

sessionId: fork.sessionId,

sessionFile: fork.sessionFile,

forkedFromParent: true,

totalTokens: undefined,

totalTokensFresh: false,

};

}

type ModelAliasIndex,

type ModelDirectiveSelection,

} from "./model-selection-directive.js";

import type { ReplySessionEntryHandle } from "./session-entry-handle.js";

/** Result of applying a reset-message model override. */

type ResetModelResult = {

function applySelectionToSession(params: {

selection: ModelDirectiveSelection;

sessionEntry?: SessionEntry;

sessionEntryHandle?: ReplySessionEntryHandle;

sessionStore?: Record<string, SessionEntry>;

sessionKey?: string;

storePath?: string;

}) {

const { selection, sessionEntry, sessionStore, sessionKey, storePath } = params;

if (!sessionEntry || !sessionStore || !sessionKey) {

const { selection, sessionEntryHandle, sessionStore, sessionKey, storePath } = params;

const sessionEntry = sessionEntryHandle?.getCurrent() ?? params.sessionEntry;

if (!sessionEntry || !sessionKey) {

return;

}

const { updated } = applyModelOverrideToSessionEntry({

if (!updated) {

return;

}

sessionStore[sessionKey] = sessionEntry;

if (sessionEntryHandle) {

sessionEntryHandle.replaceCurrent(sessionEntry);

} else if (sessionStore) {

sessionStore[sessionKey] = sessionEntry;

}

if (storePath) {

void import("../../config/sessions/session-accessor.js")

.then(({ replaceSessionEntry }) =>

sessionCtx: TemplateContext;

ctx: MsgContext;

sessionEntry?: SessionEntry;

sessionEntryHandle?: ReplySessionEntryHandle;

sessionStore?: Record<string, SessionEntry>;

sessionKey?: string;

storePath?: string;

applySelectionToSession({

selection,

sessionEntry: params.sessionEntry,

sessionEntryHandle: params.sessionEntryHandle,

sessionStore: params.sessionStore,

sessionKey: params.sessionKey,

storePath: params.storePath,