@librechat/agents 3.2.31 → 3.2.33

package/dist/esm/session/AgentSession.mjs

@@ -1,1054 +1,875 @@
-import { MemorySaver } from '@langchain/langgraph';
-import { HumanMessage, BaseMessage } from '@langchain/core/messages';
-import { deserializeMessage } from './messageSerialization.mjs';
-import { createSummarizeNode } from '../summarization/node.mjs';
-import { JsonlSessionStore } from './JsonlSessionStore.mjs';
-import { AgentContext } from '../agents/AgentContext.mjs';
-import { ContentTypes, GraphEvents } from '../common/enum.mjs';
-import { createSessionId, createRunId } from './ids.mjs';
-import { createRunHandlers } from './handlers.mjs';
-import { Run } from '../run.mjs';
-
-function isBaseMessage(value) {
-    return (value instanceof BaseMessage ||
-        (value != null &&
-            typeof value === 'object' &&
-            '_getType' in value &&
-            typeof value._getType === 'function'));
+import "../common/enum.mjs";
+import "../common/index.mjs";
+import { createSummarizeNode } from "../summarization/node.mjs";
+import { AgentContext } from "../agents/AgentContext.mjs";
+import { Run } from "../run.mjs";
+import { deserializeMessage } from "./messageSerialization.mjs";
+import { createRunId, createSessionId } from "./ids.mjs";
+import { JsonlSessionStore } from "./JsonlSessionStore.mjs";
+import { createRunHandlers } from "./handlers.mjs";
+import { BaseMessage, HumanMessage } from "@langchain/core/messages";
+import { MemorySaver } from "@langchain/langgraph";
+//#region src/session/AgentSession.ts
+function isBaseMessage$1(value) {
+	return value instanceof BaseMessage || value != null && typeof value === "object" && "_getType" in value && typeof value._getType === "function";
 }
 function normalizeInput(input) {
-    if (typeof input === 'string') {
-        const messages = [new HumanMessage(input)];
-        return { messages, state: { messages } };
-    }
-    if (Array.isArray(input)) {
-        return { messages: input, state: { messages: input } };
-    }
-    if (isBaseMessage(input)) {
-        const messages = [input];
-        return { messages, state: { messages } };
-    }
-    return { messages: input.messages, state: input };
+	if (typeof input === "string") {
+		const messages = [new HumanMessage(input)];
+		return {
+			messages,
+			state: { messages }
+		};
+	}
+	if (Array.isArray(input)) return {
+		messages: input,
+		state: { messages: input }
+	};
+	if (isBaseMessage$1(input)) {
+		const messages = [input];
+		return {
+			messages,
+			state: { messages }
+		};
+	}
+	return {
+		messages: input.messages,
+		state: input
+	};
 }
 function contentToText(content) {
-    const chunks = [];
-    for (const part of content) {
-        if (!part) {
-            continue;
-        }
-        if (part.type === ContentTypes.TEXT && typeof part.text === 'string') {
-            chunks.push(part.text);
-        }
-    }
-    return chunks.join('');
+	const chunks = [];
+	for (const part of content) {
+		if (!part) continue;
+		if (part.type === "text" && typeof part.text === "string") chunks.push(part.text);
+	}
+	return chunks.join("");
 }
 function normalizeConfig(config) {
-    if ('runConfig' in config) {
-        return {
-            runConfig: config.runConfig,
-            cwd: config.cwd ?? process.cwd(),
-            sessionPath: config.sessionPath,
-            name: config.name,
-            ephemeral: config.ephemeral,
-            checkpointing: config.checkpointing,
-        };
-    }
-    const { cwd, sessionPath, name, ephemeral, checkpointing, sessionId: _sessionId, ...runConfig } = config;
-    return {
-        runConfig: {
-            ...runConfig,
-            runId: config.runId ?? createRunId(),
-        },
-        cwd: cwd ?? process.cwd(),
-        sessionPath,
-        name,
-        ephemeral,
-        checkpointing,
-    };
+	if ("runConfig" in config) return {
+		runConfig: config.runConfig,
+		cwd: config.cwd ?? process.cwd(),
+		sessionPath: config.sessionPath,
+		name: config.name,
+		ephemeral: config.ephemeral,
+		checkpointing: config.checkpointing
+	};
+	const { cwd, sessionPath, name, ephemeral, checkpointing, sessionId: _sessionId, ...runConfig } = config;
+	return {
+		runConfig: {
+			...runConfig,
+			runId: config.runId ?? createRunId()
+		},
+		cwd: cwd ?? process.cwd(),
+		sessionPath,
+		name,
+		ephemeral,
+		checkpointing
+	};
 }
 function isMissingSessionError(error) {
-    if (error == null || typeof error !== 'object') {
-        return false;
-    }
-    const candidate = error;
-    if (candidate.code === 'ENOENT') {
-        return true;
-    }
-    return candidate.message?.startsWith('Session not found:') === true;
+	if (error == null || typeof error !== "object") return false;
+	const candidate = error;
+	if (candidate.code === "ENOENT") return true;
+	return candidate.message?.startsWith("Session not found:") === true;
 }
 async function createStore(params) {
-    if (params.ephemeral === true) {
-        return undefined;
-    }
-    if (params.sessionPath != null && params.sessionPath !== '') {
-        try {
-            return await JsonlSessionStore.openPath(params.sessionPath);
-        }
-        catch (error) {
-            if (!isMissingSessionError(error)) {
-                throw error;
-            }
-            return JsonlSessionStore.create({
-                path: params.sessionPath,
-                cwd: params.cwd,
-                name: params.name,
-                sessionId: params.sessionId,
-            });
-        }
-    }
-    return JsonlSessionStore.create({
-        cwd: params.cwd,
-        name: params.name,
-        sessionId: params.sessionId,
-    });
+	if (params.ephemeral === true) return;
+	if (params.sessionPath != null && params.sessionPath !== "") try {
+		return await JsonlSessionStore.openPath(params.sessionPath);
+	} catch (error) {
+		if (!isMissingSessionError(error)) throw error;
+		return JsonlSessionStore.create({
+			path: params.sessionPath,
+			cwd: params.cwd,
+			name: params.name,
+			sessionId: params.sessionId
+		});
+	}
+	return JsonlSessionStore.create({
+		cwd: params.cwd,
+		name: params.name,
+		sessionId: params.sessionId
+	});
 }
 function mergeInitialSummary(existing, sessionSummary) {
-    if (!existing) {
-        return sessionSummary;
-    }
-    if (!sessionSummary) {
-        return existing;
-    }
-    if (existing.text === sessionSummary.text) {
-        return existing;
-    }
-    return {
-        text: `${existing.text}\n\n${sessionSummary.text}`,
-        tokenCount: existing.tokenCount + sessionSummary.tokenCount,
-    };
+	if (!existing) return sessionSummary;
+	if (!sessionSummary) return existing;
+	if (existing.text === sessionSummary.text) return existing;
+	return {
+		text: `${existing.text}\n\n${sessionSummary.text}`,
+		tokenCount: existing.tokenCount + sessionSummary.tokenCount
+	};
 }
 function applyInitialSummaryToAgent(agent, initialSummary) {
-    const merged = mergeInitialSummary(agent.initialSummary, initialSummary);
-    return merged ? { ...agent, initialSummary: merged } : agent;
+	const merged = mergeInitialSummary(agent.initialSummary, initialSummary);
+	return merged ? {
+		...agent,
+		initialSummary: merged
+	} : agent;
 }
 function applyInitialSummaryToGraphConfig(graphConfig, initialSummary) {
-    if (!initialSummary) {
-        return graphConfig;
-    }
-    if ('agents' in graphConfig) {
-        return {
-            ...graphConfig,
-            agents: graphConfig.agents.map((agent) => applyInitialSummaryToAgent(agent, initialSummary)),
-        };
-    }
-    return {
-        ...graphConfig,
-        initialSummary: mergeInitialSummary(graphConfig.initialSummary, initialSummary),
-    };
+	if (!initialSummary) return graphConfig;
+	if ("agents" in graphConfig) return {
+		...graphConfig,
+		agents: graphConfig.agents.map((agent) => applyInitialSummaryToAgent(agent, initialSummary))
+	};
+	return {
+		...graphConfig,
+		initialSummary: mergeInitialSummary(graphConfig.initialSummary, initialSummary)
+	};
 }
 function isCheckpointSaver(value) {
-    if (value == null || typeof value !== 'object') {
-        return false;
-    }
-    const candidate = value;
-    return (typeof candidate.getTuple === 'function' &&
-        typeof candidate.list === 'function' &&
-        typeof candidate.put === 'function' &&
-        typeof candidate.putWrites === 'function' &&
-        typeof candidate.deleteThread === 'function');
+	if (value == null || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.getTuple === "function" && typeof candidate.list === "function" && typeof candidate.put === "function" && typeof candidate.putWrites === "function" && typeof candidate.deleteThread === "function";
 }
 function getGraphCheckpointer(graphConfig) {
-    const checkpointer = graphConfig.compileOptions?.checkpointer;
-    return isCheckpointSaver(checkpointer) ? checkpointer : undefined;
+	const checkpointer = graphConfig.compileOptions?.checkpointer;
+	return isCheckpointSaver(checkpointer) ? checkpointer : void 0;
 }
 function createCheckpointingState(runConfig, checkpointing) {
-    const graphCheckpointer = getGraphCheckpointer(runConfig.graphConfig);
-    if (checkpointing === false) {
-        return {
-            enabled: false,
-            disableGraphCheckpointer: true,
-        };
-    }
-    if (typeof checkpointing === 'object') {
-        if (checkpointing.enabled === false) {
-            return {
-                enabled: false,
-                disableGraphCheckpointer: true,
-            };
-        }
-        return {
-            enabled: true,
-            checkpointer: checkpointing.checkpointer ?? graphCheckpointer ?? new MemorySaver(),
-        };
-    }
-    if (checkpointing === true || runConfig.humanInTheLoop?.enabled === true) {
-        return {
-            enabled: true,
-            checkpointer: graphCheckpointer ?? new MemorySaver(),
-        };
-    }
-    return {
-        enabled: graphCheckpointer != null,
-        checkpointer: graphCheckpointer,
-    };
+	const graphCheckpointer = getGraphCheckpointer(runConfig.graphConfig);
+	if (checkpointing === false) return {
+		enabled: false,
+		disableGraphCheckpointer: true
+	};
+	if (typeof checkpointing === "object") {
+		if (checkpointing.enabled === false) return {
+			enabled: false,
+			disableGraphCheckpointer: true
+		};
+		return {
+			enabled: true,
+			checkpointer: checkpointing.checkpointer ?? graphCheckpointer ?? new MemorySaver()
+		};
+	}
+	if (checkpointing === true || runConfig.humanInTheLoop?.enabled === true) return {
+		enabled: true,
+		checkpointer: graphCheckpointer ?? new MemorySaver()
+	};
+	return {
+		enabled: graphCheckpointer != null,
+		checkpointer: graphCheckpointer
+	};
 }
 function removeCheckpointerFromGraphConfig(graphConfig) {
-    if (graphConfig.compileOptions?.checkpointer == null) {
-        return graphConfig;
-    }
-    const { checkpointer: _checkpointer, ...compileOptions } = graphConfig.compileOptions;
-    return {
-        ...graphConfig,
-        compileOptions,
-    };
+	if (graphConfig.compileOptions?.checkpointer == null) return graphConfig;
+	const { checkpointer: _checkpointer, ...compileOptions } = graphConfig.compileOptions;
+	return {
+		...graphConfig,
+		compileOptions
+	};
 }
 function applyCheckpointerToGraphConfig(graphConfig, checkpointer) {
-    if (!checkpointer) {
-        return graphConfig;
-    }
-    if (graphConfig.compileOptions?.checkpointer === checkpointer) {
-        return graphConfig;
-    }
-    return {
-        ...graphConfig,
-        compileOptions: {
-            ...(graphConfig.compileOptions ?? {}),
-            checkpointer,
-        },
-    };
+	if (!checkpointer) return graphConfig;
+	if (graphConfig.compileOptions?.checkpointer === checkpointer) return graphConfig;
+	return {
+		...graphConfig,
+		compileOptions: {
+			...graphConfig.compileOptions ?? {},
+			checkpointer
+		}
+	};
 }
 function applyCheckpointingToGraphConfig(graphConfig, checkpointing) {
-    if (checkpointing.disableGraphCheckpointer === true) {
-        return removeCheckpointerFromGraphConfig(graphConfig);
-    }
-    return applyCheckpointerToGraphConfig(graphConfig, checkpointing.checkpointer);
+	if (checkpointing.disableGraphCheckpointer === true) return removeCheckpointerFromGraphConfig(graphConfig);
+	return applyCheckpointerToGraphConfig(graphConfig, checkpointing.checkpointer);
 }
 function getConfigString(config, key) {
-    const configurable = config?.configurable;
-    const value = configurable?.[key];
-    return typeof value === 'string' && value !== '' ? value : undefined;
+	const value = (config?.configurable)?.[key];
+	return typeof value === "string" && value !== "" ? value : void 0;
 }
 function getConfigOptionalString(config, key) {
-    const configurable = config?.configurable;
-    if (configurable == null ||
-        !Object.prototype.hasOwnProperty.call(configurable, key)) {
-        return undefined;
-    }
-    const value = configurable[key];
-    return typeof value === 'string' ? value : undefined;
+	const configurable = config?.configurable;
+	if (configurable == null || !Object.prototype.hasOwnProperty.call(configurable, key)) return;
+	const value = configurable[key];
+	return typeof value === "string" ? value : void 0;
 }
 function createCallerConfig(threadId, options) {
-    return {
-        recursionLimit: 50,
-        ...(options.config ?? {}),
-        configurable: {
-            ...(options.config?.configurable ?? {}),
-            thread_id: threadId,
-        },
-        version: options.config?.version ?? 'v2',
-    };
+	return {
+		recursionLimit: 50,
+		...options.config ?? {},
+		configurable: {
+			...options.config?.configurable ?? {},
+			thread_id: threadId
+		},
+		version: options.config?.version ?? "v2"
+	};
 }
 function createCheckpointLookupConfig(config) {
-    const threadId = getConfigString(config, 'thread_id');
-    if (threadId == null) {
-        return config;
-    }
-    const checkpointNs = getConfigString(config, 'checkpoint_ns') ?? '';
-    const checkpointId = getConfigString(config, 'checkpoint_id');
-    return {
-        configurable: {
-            ...config.configurable,
-            thread_id: threadId,
-            checkpoint_ns: checkpointNs,
-            ...(checkpointId != null ? { checkpoint_id: checkpointId } : {}),
-        },
-    };
+	const threadId = getConfigString(config, "thread_id");
+	if (threadId == null) return config;
+	const checkpointNs = getConfigString(config, "checkpoint_ns") ?? "";
+	const checkpointId = getConfigString(config, "checkpoint_id");
+	return { configurable: {
+		...config.configurable,
+		thread_id: threadId,
+		checkpoint_ns: checkpointNs,
+		...checkpointId != null ? { checkpoint_id: checkpointId } : {}
+	} };
 }
 function applyCheckpointReferenceToConfig(config, checkpoint, options) {
-    if (checkpoint?.checkpointId == null ||
-        checkpoint.checkpointId === '' ||
-        (options?.overwrite !== true &&
-            getConfigString(config, 'checkpoint_id') != null)) {
-        return config;
-    }
-    return {
-        ...config,
-        configurable: {
-            ...config.configurable,
-            checkpoint_id: checkpoint.checkpointId,
-            checkpoint_ns: checkpoint.checkpointNs ?? '',
-        },
-    };
+	if (checkpoint?.checkpointId == null || checkpoint.checkpointId === "" || options?.overwrite !== true && getConfigString(config, "checkpoint_id") != null) return config;
+	return {
+		...config,
+		configurable: {
+			...config.configurable,
+			checkpoint_id: checkpoint.checkpointId,
+			checkpoint_ns: checkpoint.checkpointNs ?? ""
+		}
+	};
 }
 function getStoredCheckpointForConfig(store, threadId, config) {
-    const requestedCheckpointNs = getConfigOptionalString(config, 'checkpoint_ns');
-    if (requestedCheckpointNs == null) {
-        return store?.getLatestCheckpoint(threadId);
-    }
-    const checkpoints = store?.getCheckpoints(threadId) ?? [];
-    for (let i = checkpoints.length - 1; i >= 0; i--) {
-        const checkpoint = checkpoints[i];
-        if (checkpoint.data.source === 'reset') {
-            return undefined;
-        }
-        if ((checkpoint.data.checkpointNs ?? '') === requestedCheckpointNs) {
-            return checkpoint;
-        }
-    }
-    return undefined;
+	const requestedCheckpointNs = getConfigOptionalString(config, "checkpoint_ns");
+	if (requestedCheckpointNs == null) return store?.getLatestCheckpoint(threadId);
+	const checkpoints = store?.getCheckpoints(threadId) ?? [];
+	for (let i = checkpoints.length - 1; i >= 0; i--) {
+		const checkpoint = checkpoints[i];
+		if (checkpoint.data.source === "reset") return;
+		if ((checkpoint.data.checkpointNs ?? "") === requestedCheckpointNs) return checkpoint;
+	}
 }
 function createLatestCheckpointLookupConfig(config) {
-    const lookup = createCheckpointLookupConfig(config);
-    const { checkpoint_id: _checkpointId, ...configurable } = lookup.configurable ?? {};
-    return { configurable };
+	const { checkpoint_id: _checkpointId, ...configurable } = createCheckpointLookupConfig(config).configurable ?? {};
+	return { configurable };
 }
 async function getLatestCheckpointTuple(checkpointer, config) {
-    if (!checkpointer) {
-        return undefined;
-    }
-    const lookupConfig = createLatestCheckpointLookupConfig(config);
-    const tuple = await checkpointer.getTuple(lookupConfig);
-    if (tuple) {
-        return tuple;
-    }
-    for await (const checkpoint of checkpointer.list(lookupConfig, {
-        limit: 1,
-    })) {
-        return checkpoint;
-    }
-    return undefined;
+	if (!checkpointer) return;
+	const lookupConfig = createLatestCheckpointLookupConfig(config);
+	const tuple = await checkpointer.getTuple(lookupConfig);
+	if (tuple) return tuple;
+	for await (const checkpoint of checkpointer.list(lookupConfig, { limit: 1 })) return checkpoint;
 }
 async function getSelectedCheckpointTuple(checkpointer, config) {
-    return checkpointer?.getTuple(createCheckpointLookupConfig(config));
+	return checkpointer?.getTuple(createCheckpointLookupConfig(config));
 }
 function createCheckpointReference(params) {
-    const checkpointNs = getConfigString(params.tuple.config, 'checkpoint_ns') ?? '';
-    const parentCheckpointId = getConfigString(params.tuple.parentConfig, 'checkpoint_id');
-    return {
-        provider: 'langgraph',
-        threadId: params.threadId,
-        checkpointId: params.tuple.checkpoint.id,
-        checkpointNs,
-        ...(parentCheckpointId != null ? { parentCheckpointId } : {}),
-    };
+	const checkpointNs = getConfigString(params.tuple.config, "checkpoint_ns") ?? "";
+	const parentCheckpointId = getConfigString(params.tuple.parentConfig, "checkpoint_id");
+	return {
+		provider: "langgraph",
+		threadId: params.threadId,
+		checkpointId: params.tuple.checkpoint.id,
+		checkpointNs,
+		...parentCheckpointId != null ? { parentCheckpointId } : {}
+	};
 }
 function createSessionRunState(entries) {
-    const messages = [];
-    let initialSummary;
-    for (const entry of entries) {
-        if (entry.type === 'summary') {
-            initialSummary = {
-                text: entry.data.text,
-                tokenCount: typeof entry.data.tokenCount === 'number' &&
-                    Number.isFinite(entry.data.tokenCount)
-                    ? entry.data.tokenCount
-                    : 0,
-            };
-            messages.length = 0;
-            continue;
-        }
-        if (entry.type === 'message') {
-            messages.push(deserializeMessage(entry.data.message));
-        }
-    }
-    return { messages, initialSummary };
+	const messages = [];
+	let initialSummary;
+	for (const entry of entries) {
+		if (entry.type === "summary") {
+			initialSummary = {
+				text: entry.data.text,
+				tokenCount: typeof entry.data.tokenCount === "number" && Number.isFinite(entry.data.tokenCount) ? entry.data.tokenCount : 0
+			};
+			messages.length = 0;
+			continue;
+		}
+		if (entry.type === "message") messages.push(deserializeMessage(entry.data.message));
+	}
+	return {
+		messages,
+		initialSummary
+	};
 }
 function isMessageEntry(entry) {
-    return entry.type === 'message';
+	return entry.type === "message";
 }
 function getSessionBranchTarget(store, entryId, position) {
-    const entry = store.getEntry(entryId);
-    if (!entry) {
-        throw new Error(`Entry not found: ${entryId}`);
-    }
-    if (position === 'at') {
-        return entry;
-    }
-    return entry.parentId == null ? undefined : store.getEntry(entry.parentId);
+	const entry = store.getEntry(entryId);
+	if (!entry) throw new Error(`Entry not found: ${entryId}`);
+	if (position === "at") return entry;
+	return entry.parentId == null ? void 0 : store.getEntry(entry.parentId);
 }
 function getAbandonedPathForBranch(store, previousLeafId, targetLeafId) {
-    const previousPath = store.getPath(previousLeafId ?? undefined);
-    if (previousPath.length === 0) {
-        return [];
-    }
-    const targetPath = targetLeafId == null ? [] : store.getPath(targetLeafId);
-    const maxSharedLength = Math.min(previousPath.length, targetPath.length);
-    let sharedLength = 0;
-    while (sharedLength < maxSharedLength &&
-        previousPath[sharedLength].id === targetPath[sharedLength].id) {
-        sharedLength++;
-    }
-    return previousPath.slice(sharedLength);
+	const previousPath = store.getPath(previousLeafId ?? void 0);
+	if (previousPath.length === 0) return [];
+	const targetPath = targetLeafId == null ? [] : store.getPath(targetLeafId);
+	const maxSharedLength = Math.min(previousPath.length, targetPath.length);
+	let sharedLength = 0;
+	while (sharedLength < maxSharedLength && previousPath[sharedLength].id === targetPath[sharedLength].id) sharedLength++;
+	return previousPath.slice(sharedLength);
 }
 function createAgentInputFromGraphConfig(graphConfig, initialSummary, retainRecentTurns, instructions) {
-    let agent;
-    if ('agents' in graphConfig) {
-        if (graphConfig.agents.length === 0) {
-            throw new Error('Cannot compact a session with no agents');
-        }
-        agent = graphConfig.agents[0];
-    }
-    else {
-        const { type: _type, llmConfig, signal: _signal, tools = [], ...agentInputs } = graphConfig;
-        const { provider, ...clientOptions } = llmConfig;
-        agent = {
-            ...agentInputs,
-            tools,
-            provider,
-            clientOptions,
-            agentId: 'default',
-        };
-    }
-    const summarizationConfig = {
-        ...(agent.summarizationConfig ?? {}),
-        ...(instructions != null && instructions !== ''
-            ? { prompt: instructions }
-            : {}),
-        retainRecent: {
-            ...(agent.summarizationConfig?.retainRecent ?? {}),
-            ...(retainRecentTurns != null ? { turns: retainRecentTurns } : {}),
-        },
-    };
-    return {
-        ...applyInitialSummaryToAgent(agent, initialSummary),
-        summarizationEnabled: true,
-        summarizationConfig,
-    };
+	let agent;
+	if ("agents" in graphConfig) {
+		if (graphConfig.agents.length === 0) throw new Error("Cannot compact a session with no agents");
+		agent = graphConfig.agents[0];
+	} else {
+		const { type: _type, llmConfig, signal: _signal, tools = [], ...agentInputs } = graphConfig;
+		const { provider, ...clientOptions } = llmConfig;
+		agent = {
+			...agentInputs,
+			tools,
+			provider,
+			clientOptions,
+			agentId: "default"
+		};
+	}
+	const summarizationConfig = {
+		...agent.summarizationConfig ?? {},
+		...instructions != null && instructions !== "" ? { prompt: instructions } : {},
+		retainRecent: {
+			...agent.summarizationConfig?.retainRecent ?? {},
+			...retainRecentTurns != null ? { turns: retainRecentTurns } : {}
+		}
+	};
+	return {
+		...applyInitialSummaryToAgent(agent, initialSummary),
+		summarizationEnabled: true,
+		summarizationConfig
+	};
 }
 function createManualCompactGraph(params) {
-    const contentData = [];
-    const contentIndexMap = new Map();
-    const result = {
-        graph: {
-            contentData,
-            contentIndexMap,
-            runId: params.runId,
-            isMultiAgent: false,
-            hookRegistry: params.hooks,
-            dispatchRunStep: async (runStep) => {
-                contentData.push(runStep);
-                contentIndexMap.set(runStep.id, runStep.index);
-                await params.customHandlers?.[GraphEvents.ON_RUN_STEP]?.handle(GraphEvents.ON_RUN_STEP, runStep);
-            },
-            dispatchRunStepCompleted: async (stepId, completed) => {
-                const runStep = contentData.find((step) => step.id === stepId);
-                const resultWithStep = {
-                    ...completed,
-                    id: stepId,
-                    index: runStep?.index ?? 0,
-                };
-                if (completed.type === 'summary') {
-                    result.completedSummary = completed.summary;
-                }
-                await params.customHandlers?.[GraphEvents.ON_RUN_STEP_COMPLETED]?.handle(GraphEvents.ON_RUN_STEP_COMPLETED, {
-                    result: resultWithStep,
-                });
-            },
-        },
-    };
-    return result;
+	const contentData = [];
+	const contentIndexMap = /* @__PURE__ */ new Map();
+	const result = { graph: {
+		contentData,
+		contentIndexMap,
+		runId: params.runId,
+		isMultiAgent: false,
+		hookRegistry: params.hooks,
+		dispatchRunStep: async (runStep) => {
+			contentData.push(runStep);
+			contentIndexMap.set(runStep.id, runStep.index);
+			await params.customHandlers?.["on_run_step"]?.handle("on_run_step", runStep);
+		},
+		dispatchRunStepCompleted: async (stepId, completed) => {
+			const runStep = contentData.find((step) => step.id === stepId);
+			const resultWithStep = {
+				...completed,
+				id: stepId,
+				index: runStep?.index ?? 0
+			};
+			if (completed.type === "summary") result.completedSummary = completed.summary;
+			await params.customHandlers?.["on_run_step_completed"]?.handle("on_run_step_completed", { result: resultWithStep });
+		}
+	} };
+	return result;
 }
 function getSummaryText(summary) {
-    const firstBlock = summary?.content?.[0];
-    return firstBlock != null &&
-        typeof firstBlock === 'object' &&
-        'text' in firstBlock &&
-        typeof firstBlock.text === 'string'
-        ? firstBlock.text
-        : '';
+	const firstBlock = summary?.content?.[0];
+	return firstBlock != null && typeof firstBlock === "object" && "text" in firstBlock && typeof firstBlock.text === "string" ? firstBlock.text : "";
 }
 function getSummaryTokenCount(summary) {
-    return typeof summary?.tokenCount === 'number' &&
-        Number.isFinite(summary.tokenCount)
-        ? summary.tokenCount
-        : 0;
+	return typeof summary?.tokenCount === "number" && Number.isFinite(summary.tokenCount) ? summary.tokenCount : 0;
 }
 function filterRemoveMessages(messages) {
-    return messages.filter((message) => message._getType() !== 'remove');
-}
-class LiveAgentSessionStream {
-    resultPromise;
-    events = [];
-    waiters = [];
-    closed = false;
-    failed = false;
-    error;
-    setResultPromise(resultPromise) {
-        this.resultPromise = resultPromise;
-    }
-    push(event) {
-        if (this.closed) {
-            return;
-        }
-        const waiter = this.waiters.shift();
-        if (waiter) {
-            waiter.resolve({ value: event, done: false });
-            return;
-        }
-        this.events.push(event);
-    }
-    complete() {
-        this.closed = true;
-        for (const waiter of this.waiters.splice(0)) {
-            waiter.resolve({
-                value: undefined,
-                done: true,
-            });
-        }
-    }
-    fail(error) {
-        this.error = error;
-        this.failed = true;
-        this.closed = true;
-        for (const waiter of this.waiters.splice(0)) {
-            waiter.reject(error);
-        }
-    }
-    nextEvent() {
-        const event = this.events.shift();
-        if (event !== undefined) {
-            return Promise.resolve({ value: event, done: false });
-        }
-        if (this.failed) {
-            return Promise.reject(this.error);
-        }
-        if (this.closed) {
-            return Promise.resolve({
-                value: undefined,
-                done: true,
-            });
-        }
-        return new Promise((resolve, reject) => {
-            this.waiters.push({ resolve, reject });
-        });
-    }
-    async *[Symbol.asyncIterator]() {
-        for (;;) {
-            const next = await this.nextEvent();
-            if (next.done === true) {
-                return;
-            }
-            yield next.value;
-        }
-    }
-    async *toTextStream() {
-        for await (const event of this) {
-            if (event.type !== 'message.delta' || event.data == null) {
-                continue;
-            }
-            const data = event.data;
-            if (typeof data === 'object' && !Array.isArray(data)) {
-                const delta = data.delta;
-                if (delta != null &&
-                    typeof delta === 'object' &&
-                    !Array.isArray(delta)) {
-                    const content = delta.content;
-                    if (Array.isArray(content)) {
-                        for (const part of content) {
-                            if (part != null &&
-                                typeof part === 'object' &&
-                                !Array.isArray(part) &&
-                                typeof part.text === 'string') {
-                                yield part.text;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    finalResult() {
-        if (!this.resultPromise) {
-            return Promise.reject(new Error('Session stream has not started'));
-        }
-        return this.resultPromise;
-    }
-}
-class AgentSession {
-    runConfig;
-    store;
-    calibrationRatio;
-    checkpointing;
-    cwd;
-    threadId;
-    constructor(params) {
-        this.runConfig = params.runConfig;
-        this.cwd = params.cwd;
-        this.threadId = params.threadId;
-        this.store = params.store;
-        this.checkpointing = params.checkpointing;
-    }
-    static async create(config) {
-        const normalized = normalizeConfig(config);
-        const explicitSessionId = 'sessionId' in config && typeof config.sessionId === 'string'
-            ? config.sessionId
-            : undefined;
-        const store = await createStore({
-            cwd: normalized.cwd,
-            sessionPath: normalized.sessionPath,
-            name: normalized.name,
-            sessionId: explicitSessionId,
-            ephemeral: normalized.ephemeral,
-        });
-        return new AgentSession({
-            runConfig: normalized.runConfig,
-            cwd: normalized.cwd,
-            threadId: store?.header.id ?? explicitSessionId ?? createSessionId(),
-            checkpointing: createCheckpointingState(normalized.runConfig, normalized.checkpointing),
-            store,
-        });
-    }
-    get sessionPath() {
-        return this.store?.path;
-    }
-    getSessionStore() {
-        return this.store;
-    }
-    getCheckpointer() {
-        return this.checkpointing.checkpointer;
-    }
-    async getLatestCheckpoint(options = {}) {
-        const threadId = options.threadId ?? this.threadId;
-        const baseConfig = options.config ?? {};
-        const config = createCheckpointLookupConfig({
-            ...baseConfig,
-            configurable: {
-                ...(baseConfig.configurable ?? {}),
-                thread_id: threadId,
-                ...(options.checkpointNs != null
-                    ? { checkpoint_ns: options.checkpointNs }
-                    : {}),
-            },
-        });
-        const tuple = await getLatestCheckpointTuple(this.checkpointing.checkpointer, config);
-        return tuple ? createCheckpointReference({ threadId, tuple }) : undefined;
-    }
-    async hasCheckpointState(config) {
-        if (!this.checkpointing.enabled) {
-            return false;
-        }
-        const tuple = await getSelectedCheckpointTuple(this.checkpointing.checkpointer, config);
-        return tuple != null;
-    }
-    async recordCheckpoint(params) {
-        if (!this.checkpointing.enabled) {
-            return;
-        }
-        const checkpointConfig = applyCheckpointReferenceToConfig(params.config, {
-            checkpointId: params.checkpointId,
-            checkpointNs: params.checkpointNs,
-        }, { overwrite: true });
-        const tuple = params.checkpointId != null && params.checkpointId !== ''
-            ? await getSelectedCheckpointTuple(this.checkpointing.checkpointer, checkpointConfig)
-            : await getLatestCheckpointTuple(this.checkpointing.checkpointer, params.config);
-        if (!tuple) {
-            return;
-        }
-        const reference = createCheckpointReference({
-            threadId: params.threadId,
-            tuple,
-        });
-        await this.store?.appendCheckpoint({
-            source: params.source,
-            runId: params.runId,
-            threadId: params.threadId,
-            checkpointId: reference.checkpointId,
-            checkpointNs: reference.checkpointNs,
-            parentCheckpointId: reference.parentCheckpointId,
-        });
-    }
-    getCheckpointThreadIds() {
-        const threadIds = new Set([this.threadId]);
-        for (const checkpoint of this.store?.getCheckpoints() ?? []) {
-            threadIds.add(checkpoint.data.threadId);
-        }
-        return [...threadIds];
-    }
-    async resetCheckpointThreads(reason) {
-        const checkpointer = this.checkpointing.checkpointer;
-        if (!this.checkpointing.enabled || checkpointer == null) {
-            return;
-        }
-        for (const threadId of this.getCheckpointThreadIds()) {
-            await checkpointer.deleteThread(threadId);
-            await this.store?.appendCheckpoint({
-                source: 'reset',
-                threadId,
-                reason,
-            });
-        }
-    }
-    async runInternal(input, options = {}, onEvent) {
-        const runId = options.runId ?? createRunId();
-        const threadId = options.threadId ?? this.threadId;
-        const isSessionThread = threadId === this.threadId;
-        const normalizedInput = normalizeInput(input);
-        const inputMessages = normalizedInput.messages;
-        const callerConfig = createCallerConfig(threadId, options);
-        const useCheckpointState = await this.hasCheckpointState(callerConfig);
-        let parentId = this.store?.getLeafEntry()?.id ?? null;
-        if (isSessionThread) {
-            for (const message of inputMessages) {
-                const entry = await this.store?.appendMessage(message, parentId);
-                parentId = entry?.id ?? parentId;
-            }
-        }
-        await this.store?.appendRunEvent('run.started', undefined, {
-            runId,
-            threadId,
-        });
-        const handlerResult = createRunHandlers({
-            runId,
-            threadId,
-            userHandlers: this.runConfig.customHandlers,
-            onEvent,
-        });
-        const emitTerminalEvent = (event) => {
-            const streamEvent = {
-                ...event,
-                sequence: handlerResult.events.length,
-                runId,
-                threadId,
-                timestamp: new Date().toISOString(),
-            };
-            handlerResult.events.push(streamEvent);
-            onEvent?.(streamEvent);
-        };
-        const sessionState = createSessionRunState(isSessionThread ? (this.store?.getPath() ?? []) : []);
-        try {
-            const runConfig = {
-                ...this.runConfig,
-                runId,
-                graphConfig: applyCheckpointingToGraphConfig(applyInitialSummaryToGraphConfig(this.runConfig.graphConfig, sessionState.initialSummary), this.checkpointing),
-                returnContent: true,
-                calibrationRatio: this.calibrationRatio,
-                customHandlers: {
-                    ...(this.runConfig.customHandlers ?? {}),
-                    ...handlerResult.handlers,
-                },
-            };
-            const run = await Run.create(runConfig);
-            let messages = inputMessages;
-            if (!useCheckpointState && sessionState.messages.length > 0) {
-                messages = sessionState.messages;
-            }
-            const content = await run.processStream({ ...normalizedInput.state, messages }, callerConfig, options.streamOptions);
-            const runMessages = run.getRunMessages() ?? [];
-            if (isSessionThread) {
-                for (const message of runMessages) {
-                    await this.store?.appendMessage(message);
-                }
-            }
-            this.calibrationRatio = run.getCalibrationRatio();
-            const interrupt = run.getInterrupt();
-            const haltedReason = run.getHaltReason();
-            if (interrupt) {
-                emitTerminalEvent({ type: 'run.interrupted' });
-                await this.store?.appendRunEvent('run.interrupted', interrupt, {
-                    runId,
-                    threadId,
-                });
-            }
-            else if (haltedReason != null && haltedReason !== '') {
-                emitTerminalEvent({ type: 'run.halted', data: haltedReason });
-                await this.store?.appendRunEvent('run.halted', haltedReason, {
-                    runId,
-                    threadId,
-                });
-            }
-            else {
-                emitTerminalEvent({ type: 'run.completed' });
-                await this.store?.appendRunEvent('run.completed', undefined, {
-                    runId,
-                    threadId,
-                });
-            }
-            await this.recordCheckpoint({
-                source: 'run',
-                runId,
-                threadId,
-                config: callerConfig,
-                checkpointId: interrupt?.checkpointId,
-                checkpointNs: interrupt?.checkpointNs,
-            });
-            const contentParts = (content ?? handlerResult.contentParts).filter((part) => part != null);
-            return {
-                text: contentToText(contentParts),
-                content: contentParts,
-                messages: runMessages,
-                usage: handlerResult.usage,
-                steps: handlerResult.steps,
-                interrupt,
-                haltedReason,
-                runId,
-                threadId,
-            };
-        }
-        catch (error) {
-            emitTerminalEvent({
-                type: 'run.failed',
-                data: error instanceof Error ? error.message : String(error),
-            });
-            await this.store?.appendRunEvent('run.failed', error, {
-                runId,
-                threadId,
-            });
-            await this.recordCheckpoint({
-                source: 'run',
-                runId,
-                threadId,
-                config: callerConfig,
-            });
-            throw error;
-        }
-    }
-    async run(input, options = {}) {
-        return this.runInternal(input, options);
-    }
-    stream(input, options = {}) {
-        const stream = new LiveAgentSessionStream();
-        const resultPromise = this.runInternal(input, options, (event) => {
-            stream.push(event);
-        }).then((result) => {
-            stream.complete();
-            return result;
-        }, (error) => {
-            stream.fail(error);
-            throw error;
-        });
-        stream.setResultPromise(resultPromise);
-        return stream;
-    }
-    async resumeSession(pathOrId) {
-        if (pathOrId == null || pathOrId === '') {
-            const sessions = await JsonlSessionStore.list(this.cwd);
-            if (sessions.length === 0) {
-                throw new Error(`No sessions found for ${this.cwd}`);
-            }
-            this.store = await JsonlSessionStore.open(sessions[0].path);
-            this.cwd = this.store.header.cwd;
-            this.threadId = this.store.header.id;
-            return this;
-        }
-        this.store = await JsonlSessionStore.open(pathOrId);
-        this.cwd = this.store.header.cwd;
-        this.threadId = this.store.header.id;
-        return this;
-    }
-    async clone(options = {}) {
-        if (!this.store) {
-            throw new Error('Cannot clone an ephemeral session');
-        }
-        const store = await this.store.clone(options);
-        return new AgentSession({
-            runConfig: this.runConfig,
-            cwd: store.header.cwd,
-            threadId: store.header.id,
-            checkpointing: this.checkpointing,
-            store,
-        });
-    }
-    async fork(entryId, options = {}) {
-        if (!this.store) {
-            throw new Error('Cannot fork an ephemeral session');
-        }
-        const store = await this.store.fork(entryId, options);
-        return new AgentSession({
-            runConfig: this.runConfig,
-            cwd: store.header.cwd,
-            threadId: store.header.id,
-            checkpointing: this.checkpointing,
-            store,
-        });
-    }
-    async branch(entryId, options = {}) {
-        const store = this.store;
-        if (!store) {
-            throw new Error('Cannot branch an ephemeral session');
-        }
-        const target = getSessionBranchTarget(store, entryId, options.position ?? 'at');
-        const previousLeafId = store.getLeafEntry()?.id ?? null;
-        let leafId = target?.id ?? null;
-        const summarizeAbandoned = options.summarizeAbandoned;
-        if (summarizeAbandoned !== undefined && summarizeAbandoned !== false) {
-            const instructions = typeof summarizeAbandoned === 'object'
-                ? summarizeAbandoned.instructions
-                : undefined;
-            const abandonedPath = getAbandonedPathForBranch(store, previousLeafId, leafId);
-            const summary = await this.compactActivePath({ instructions, retainRecentTurns: 0 }, leafId, abandonedPath);
-            leafId = summary?.id ?? leafId;
-        }
-        if (leafId === previousLeafId) {
-            return;
-        }
-        await store.setLeaf(leafId);
-        await this.resetCheckpointThreads('branch');
-    }
-    async compact(options = {}) {
-        const summary = await this.compactActivePath(options, null);
-        if (summary) {
-            await this.resetCheckpointThreads('compact');
-        }
-    }
-    async compactActivePath(options = {}, parentId, path) {
-        const store = this.store;
-        if (!store) {
-            throw new Error('Cannot compact an ephemeral session');
-        }
-        const activePath = path ?? store.getPath();
-        const sessionState = createSessionRunState(activePath);
-        const messageEntries = activePath.filter(isMessageEntry);
-        if (sessionState.messages.length === 0) {
-            return undefined;
-        }
-        const compactRunId = createRunId();
-        const agentContext = AgentContext.fromConfig(createAgentInputFromGraphConfig(this.runConfig.graphConfig, sessionState.initialSummary, options.retainRecentTurns, options.instructions), this.runConfig.tokenCounter);
-        const graph = createManualCompactGraph({
-            runId: compactRunId,
-            customHandlers: this.runConfig.customHandlers,
-            hooks: this.runConfig.hooks,
-        });
-        const summarizeNode = createSummarizeNode({
-            agentContext,
-            graph: graph.graph,
-            generateStepId: (stepKey) => [
-                `${stepKey}-${compactRunId}`,
-                graph.graph.contentData.length,
-            ],
-        });
-        const summarizedState = await summarizeNode({
-            messages: sessionState.messages,
-            summarizationRequest: {
-                remainingContextTokens: agentContext.maxContextTokens ?? 0,
-                agentId: agentContext.agentId,
-            },
-        }, {
-            configurable: { thread_id: this.threadId },
-            metadata: { run_id: compactRunId },
-        });
-        const completedSummaryText = getSummaryText(graph.completedSummary);
-        const contextSummaryText = agentContext.getSummaryText();
-        let summaryText = completedSummaryText;
-        if (summaryText === '' && contextSummaryText != null) {
-            summaryText = contextSummaryText;
-        }
-        if (summaryText === '') {
-            return undefined;
-        }
-        const retainedMessages = filterRemoveMessages(summarizedState.messages ?? []);
-        let retainedEntryIds = [];
-        if (retainedMessages.length > 0) {
-            retainedEntryIds = messageEntries
-                .slice(-retainedMessages.length)
-                .map((entry) => entry.id);
-        }
-        const retainedEntryIdSet = new Set(retainedEntryIds);
-        const summarized = messageEntries.filter((entry) => !retainedEntryIdSet.has(entry.id));
-        const summary = await store.appendEntryForCompaction({
-            text: summaryText,
-            tokenCount: getSummaryTokenCount(graph.completedSummary),
-            retainedEntryIds,
-            summarizedEntryIds: summarized.map((entry) => entry.id),
-            instructions: options.instructions,
-            parentId,
-        });
-        let retainedParentId = summary.id;
-        for (const message of retainedMessages) {
-            const retainedMessage = await store.appendMessage(message, retainedParentId);
-            retainedParentId = retainedMessage.id;
-        }
-        await store.appendCompactionEntry({
-            summaryEntryId: summary.id,
-            retainedEntryIds,
-            summarizedEntryIds: summarized.map((entry) => entry.id),
-        });
-        return summary;
-    }
-    async resumeInterrupt(resumeValue, options = {}) {
-        const runId = options.runId ?? createRunId();
-        const threadId = options.threadId ?? this.threadId;
-        const isSessionThread = threadId === this.threadId;
-        const baseCallerConfig = createCallerConfig(threadId, options);
-        const callerConfig = applyCheckpointReferenceToConfig(baseCallerConfig, getStoredCheckpointForConfig(this.store, threadId, baseCallerConfig)?.data);
-        await this.store?.appendRunEvent('run.started', undefined, {
-            runId,
-            threadId,
-        });
-        const handlerResult = createRunHandlers({
-            runId,
-            threadId,
-            userHandlers: this.runConfig.customHandlers,
-        });
-        const sessionState = createSessionRunState(isSessionThread ? (this.store?.getPath() ?? []) : []);
-        try {
-            const run = await Run.create({
-                ...this.runConfig,
-                runId,
-                graphConfig: applyCheckpointingToGraphConfig(applyInitialSummaryToGraphConfig(this.runConfig.graphConfig, sessionState.initialSummary), this.checkpointing),
-                returnContent: true,
-                calibrationRatio: this.calibrationRatio,
-                customHandlers: {
-                    ...(this.runConfig.customHandlers ?? {}),
-                    ...handlerResult.handlers,
-                },
-            });
-            const content = await run.resume(resumeValue, callerConfig);
-            const runMessages = run.getRunMessages() ?? [];
-            if (isSessionThread) {
-                for (const message of runMessages) {
-                    await this.store?.appendMessage(message);
-                }
-            }
-            this.calibrationRatio = run.getCalibrationRatio();
-            const interrupt = run.getInterrupt();
-            const haltedReason = run.getHaltReason();
-            if (interrupt) {
-                await this.store?.appendRunEvent('run.interrupted', interrupt, {
-                    runId,
-                    threadId,
-                });
-            }
-            else if (haltedReason != null && haltedReason !== '') {
-                await this.store?.appendRunEvent('run.halted', haltedReason, {
-                    runId,
-                    threadId,
-                });
-            }
-            else {
-                await this.store?.appendRunEvent('run.completed', undefined, {
-                    runId,
-                    threadId,
-                });
-            }
-            await this.recordCheckpoint({
-                source: 'resume',
-                runId,
-                threadId,
-                config: callerConfig,
-                checkpointId: interrupt?.checkpointId,
-                checkpointNs: interrupt?.checkpointNs,
-            });
-            const contentParts = (content ?? handlerResult.contentParts).filter((part) => part != null);
-            return {
-                text: contentToText(contentParts),
-                content: contentParts,
-                messages: runMessages,
-                usage: handlerResult.usage,
-                steps: handlerResult.steps,
-                interrupt,
-                haltedReason,
-                runId,
-                threadId,
-            };
-        }
-        catch (error) {
-            await this.store?.appendRunEvent('run.failed', error, {
-                runId,
-                threadId,
-            });
-            await this.recordCheckpoint({
-                source: 'resume',
-                runId,
-                threadId,
-                config: callerConfig,
-            });
-            throw error;
-        }
-    }
-}
+	return messages.filter((message) => message._getType() !== "remove");
+}
+var LiveAgentSessionStream = class {
+	resultPromise;
+	events = [];
+	waiters = [];
+	closed = false;
+	failed = false;
+	error;
+	setResultPromise(resultPromise) {
+		this.resultPromise = resultPromise;
+	}
+	push(event) {
+		if (this.closed) return;
+		const waiter = this.waiters.shift();
+		if (waiter) {
+			waiter.resolve({
+				value: event,
+				done: false
+			});
+			return;
+		}
+		this.events.push(event);
+	}
+	complete() {
+		this.closed = true;
+		for (const waiter of this.waiters.splice(0)) waiter.resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	fail(error) {
+		this.error = error;
+		this.failed = true;
+		this.closed = true;
+		for (const waiter of this.waiters.splice(0)) waiter.reject(error);
+	}
+	nextEvent() {
+		const event = this.events.shift();
+		if (event !== void 0) return Promise.resolve({
+			value: event,
+			done: false
+		});
+		if (this.failed) return Promise.reject(this.error);
+		if (this.closed) return Promise.resolve({
+			value: void 0,
+			done: true
+		});
+		return new Promise((resolve, reject) => {
+			this.waiters.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		for (;;) {
+			const next = await this.nextEvent();
+			if (next.done === true) return;
+			yield next.value;
+		}
+	}
+	async *toTextStream() {
+		for await (const event of this) {
+			if (event.type !== "message.delta" || event.data == null) continue;
+			const data = event.data;
+			if (typeof data === "object" && !Array.isArray(data)) {
+				const delta = data.delta;
+				if (delta != null && typeof delta === "object" && !Array.isArray(delta)) {
+					const content = delta.content;
+					if (Array.isArray(content)) {
+						for (const part of content) if (part != null && typeof part === "object" && !Array.isArray(part) && typeof part.text === "string") yield part.text;
+					}
+				}
+			}
+		}
+	}
+	finalResult() {
+		if (!this.resultPromise) return Promise.reject(/* @__PURE__ */ new Error("Session stream has not started"));
+		return this.resultPromise;
+	}
+};
+var AgentSession = class AgentSession {
+	runConfig;
+	store;
+	calibrationRatio;
+	checkpointing;
+	cwd;
+	threadId;
+	constructor(params) {
+		this.runConfig = params.runConfig;
+		this.cwd = params.cwd;
+		this.threadId = params.threadId;
+		this.store = params.store;
+		this.checkpointing = params.checkpointing;
+	}
+	static async create(config) {
+		const normalized = normalizeConfig(config);
+		const explicitSessionId = "sessionId" in config && typeof config.sessionId === "string" ? config.sessionId : void 0;
+		const store = await createStore({
+			cwd: normalized.cwd,
+			sessionPath: normalized.sessionPath,
+			name: normalized.name,
+			sessionId: explicitSessionId,
+			ephemeral: normalized.ephemeral
+		});
+		return new AgentSession({
+			runConfig: normalized.runConfig,
+			cwd: normalized.cwd,
+			threadId: store?.header.id ?? explicitSessionId ?? createSessionId(),
+			checkpointing: createCheckpointingState(normalized.runConfig, normalized.checkpointing),
+			store
+		});
+	}
+	get sessionPath() {
+		return this.store?.path;
+	}
+	getSessionStore() {
+		return this.store;
+	}
+	getCheckpointer() {
+		return this.checkpointing.checkpointer;
+	}
+	async getLatestCheckpoint(options = {}) {
+		const threadId = options.threadId ?? this.threadId;
+		const baseConfig = options.config ?? {};
+		const config = createCheckpointLookupConfig({
+			...baseConfig,
+			configurable: {
+				...baseConfig.configurable ?? {},
+				thread_id: threadId,
+				...options.checkpointNs != null ? { checkpoint_ns: options.checkpointNs } : {}
+			}
+		});
+		const tuple = await getLatestCheckpointTuple(this.checkpointing.checkpointer, config);
+		return tuple ? createCheckpointReference({
+			threadId,
+			tuple
+		}) : void 0;
+	}
+	async hasCheckpointState(config) {
+		if (!this.checkpointing.enabled) return false;
+		return await getSelectedCheckpointTuple(this.checkpointing.checkpointer, config) != null;
+	}
+	async recordCheckpoint(params) {
+		if (!this.checkpointing.enabled) return;
+		const checkpointConfig = applyCheckpointReferenceToConfig(params.config, {
+			checkpointId: params.checkpointId,
+			checkpointNs: params.checkpointNs
+		}, { overwrite: true });
+		const tuple = params.checkpointId != null && params.checkpointId !== "" ? await getSelectedCheckpointTuple(this.checkpointing.checkpointer, checkpointConfig) : await getLatestCheckpointTuple(this.checkpointing.checkpointer, params.config);
+		if (!tuple) return;
+		const reference = createCheckpointReference({
+			threadId: params.threadId,
+			tuple
+		});
+		await this.store?.appendCheckpoint({
+			source: params.source,
+			runId: params.runId,
+			threadId: params.threadId,
+			checkpointId: reference.checkpointId,
+			checkpointNs: reference.checkpointNs,
+			parentCheckpointId: reference.parentCheckpointId
+		});
+	}
+	getCheckpointThreadIds() {
+		const threadIds = new Set([this.threadId]);
+		for (const checkpoint of this.store?.getCheckpoints() ?? []) threadIds.add(checkpoint.data.threadId);
+		return [...threadIds];
+	}
+	async resetCheckpointThreads(reason) {
+		const checkpointer = this.checkpointing.checkpointer;
+		if (!this.checkpointing.enabled || checkpointer == null) return;
+		for (const threadId of this.getCheckpointThreadIds()) {
+			await checkpointer.deleteThread(threadId);
+			await this.store?.appendCheckpoint({
+				source: "reset",
+				threadId,
+				reason
+			});
+		}
+	}
+	async runInternal(input, options = {}, onEvent) {
+		const runId = options.runId ?? createRunId();
+		const threadId = options.threadId ?? this.threadId;
+		const isSessionThread = threadId === this.threadId;
+		const normalizedInput = normalizeInput(input);
+		const inputMessages = normalizedInput.messages;
+		const callerConfig = createCallerConfig(threadId, options);
+		const useCheckpointState = await this.hasCheckpointState(callerConfig);
+		let parentId = this.store?.getLeafEntry()?.id ?? null;
+		if (isSessionThread) for (const message of inputMessages) parentId = (await this.store?.appendMessage(message, parentId))?.id ?? parentId;
+		await this.store?.appendRunEvent("run.started", void 0, {
+			runId,
+			threadId
+		});
+		const handlerResult = createRunHandlers({
+			runId,
+			threadId,
+			userHandlers: this.runConfig.customHandlers,
+			onEvent
+		});
+		const emitTerminalEvent = (event) => {
+			const streamEvent = {
+				...event,
+				sequence: handlerResult.events.length,
+				runId,
+				threadId,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			handlerResult.events.push(streamEvent);
+			onEvent?.(streamEvent);
+		};
+		const sessionState = createSessionRunState(isSessionThread ? this.store?.getPath() ?? [] : []);
+		try {
+			const runConfig = {
+				...this.runConfig,
+				runId,
+				graphConfig: applyCheckpointingToGraphConfig(applyInitialSummaryToGraphConfig(this.runConfig.graphConfig, sessionState.initialSummary), this.checkpointing),
+				returnContent: true,
+				calibrationRatio: this.calibrationRatio,
+				customHandlers: {
+					...this.runConfig.customHandlers ?? {},
+					...handlerResult.handlers
+				}
+			};
+			const run = await Run.create(runConfig);
+			let messages = inputMessages;
+			if (!useCheckpointState && sessionState.messages.length > 0) messages = sessionState.messages;
+			const content = await run.processStream({
+				...normalizedInput.state,
+				messages
+			}, callerConfig, options.streamOptions);
+			const runMessages = run.getRunMessages() ?? [];
+			if (isSessionThread) for (const message of runMessages) await this.store?.appendMessage(message);
+			this.calibrationRatio = run.getCalibrationRatio();
+			const interrupt = run.getInterrupt();
+			const haltedReason = run.getHaltReason();
+			if (interrupt) {
+				emitTerminalEvent({ type: "run.interrupted" });
+				await this.store?.appendRunEvent("run.interrupted", interrupt, {
+					runId,
+					threadId
+				});
+			} else if (haltedReason != null && haltedReason !== "") {
+				emitTerminalEvent({
+					type: "run.halted",
+					data: haltedReason
+				});
+				await this.store?.appendRunEvent("run.halted", haltedReason, {
+					runId,
+					threadId
+				});
+			} else {
+				emitTerminalEvent({ type: "run.completed" });
+				await this.store?.appendRunEvent("run.completed", void 0, {
+					runId,
+					threadId
+				});
+			}
+			await this.recordCheckpoint({
+				source: "run",
+				runId,
+				threadId,
+				config: callerConfig,
+				checkpointId: interrupt?.checkpointId,
+				checkpointNs: interrupt?.checkpointNs
+			});
+			const contentParts = (content ?? handlerResult.contentParts).filter((part) => part != null);
+			return {
+				text: contentToText(contentParts),
+				content: contentParts,
+				messages: runMessages,
+				usage: handlerResult.usage,
+				steps: handlerResult.steps,
+				interrupt,
+				haltedReason,
+				runId,
+				threadId
+			};
+		} catch (error) {
+			emitTerminalEvent({
+				type: "run.failed",
+				data: error instanceof Error ? error.message : String(error)
+			});
+			await this.store?.appendRunEvent("run.failed", error, {
+				runId,
+				threadId
+			});
+			await this.recordCheckpoint({
+				source: "run",
+				runId,
+				threadId,
+				config: callerConfig
+			});
+			throw error;
+		}
+	}
+	async run(input, options = {}) {
+		return this.runInternal(input, options);
+	}
+	stream(input, options = {}) {
+		const stream = new LiveAgentSessionStream();
+		const resultPromise = this.runInternal(input, options, (event) => {
+			stream.push(event);
+		}).then((result) => {
+			stream.complete();
+			return result;
+		}, (error) => {
+			stream.fail(error);
+			throw error;
+		});
+		stream.setResultPromise(resultPromise);
+		return stream;
+	}
+	async resumeSession(pathOrId) {
+		if (pathOrId == null || pathOrId === "") {
+			const sessions = await JsonlSessionStore.list(this.cwd);
+			if (sessions.length === 0) throw new Error(`No sessions found for ${this.cwd}`);
+			this.store = await JsonlSessionStore.open(sessions[0].path);
+			this.cwd = this.store.header.cwd;
+			this.threadId = this.store.header.id;
+			return this;
+		}
+		this.store = await JsonlSessionStore.open(pathOrId);
+		this.cwd = this.store.header.cwd;
+		this.threadId = this.store.header.id;
+		return this;
+	}
+	async clone(options = {}) {
+		if (!this.store) throw new Error("Cannot clone an ephemeral session");
+		const store = await this.store.clone(options);
+		return new AgentSession({
+			runConfig: this.runConfig,
+			cwd: store.header.cwd,
+			threadId: store.header.id,
+			checkpointing: this.checkpointing,
+			store
+		});
+	}
+	async fork(entryId, options = {}) {
+		if (!this.store) throw new Error("Cannot fork an ephemeral session");
+		const store = await this.store.fork(entryId, options);
+		return new AgentSession({
+			runConfig: this.runConfig,
+			cwd: store.header.cwd,
+			threadId: store.header.id,
+			checkpointing: this.checkpointing,
+			store
+		});
+	}
+	async branch(entryId, options = {}) {
+		const store = this.store;
+		if (!store) throw new Error("Cannot branch an ephemeral session");
+		const target = getSessionBranchTarget(store, entryId, options.position ?? "at");
+		const previousLeafId = store.getLeafEntry()?.id ?? null;
+		let leafId = target?.id ?? null;
+		const summarizeAbandoned = options.summarizeAbandoned;
+		if (summarizeAbandoned !== void 0 && summarizeAbandoned !== false) {
+			const instructions = typeof summarizeAbandoned === "object" ? summarizeAbandoned.instructions : void 0;
+			const abandonedPath = getAbandonedPathForBranch(store, previousLeafId, leafId);
+			leafId = (await this.compactActivePath({
+				instructions,
+				retainRecentTurns: 0
+			}, leafId, abandonedPath))?.id ?? leafId;
+		}
+		if (leafId === previousLeafId) return;
+		await store.setLeaf(leafId);
+		await this.resetCheckpointThreads("branch");
+	}
+	async compact(options = {}) {
+		if (await this.compactActivePath(options, null)) await this.resetCheckpointThreads("compact");
+	}
+	async compactActivePath(options = {}, parentId, path) {
+		const store = this.store;
+		if (!store) throw new Error("Cannot compact an ephemeral session");
+		const activePath = path ?? store.getPath();
+		const sessionState = createSessionRunState(activePath);
+		const messageEntries = activePath.filter(isMessageEntry);
+		if (sessionState.messages.length === 0) return;
+		const compactRunId = createRunId();
+		const agentContext = AgentContext.fromConfig(createAgentInputFromGraphConfig(this.runConfig.graphConfig, sessionState.initialSummary, options.retainRecentTurns, options.instructions), this.runConfig.tokenCounter);
+		const graph = createManualCompactGraph({
+			runId: compactRunId,
+			customHandlers: this.runConfig.customHandlers,
+			hooks: this.runConfig.hooks
+		});
+		const summarizedState = await createSummarizeNode({
+			agentContext,
+			graph: graph.graph,
+			generateStepId: (stepKey) => [`${stepKey}-${compactRunId}`, graph.graph.contentData.length]
+		})({
+			messages: sessionState.messages,
+			summarizationRequest: {
+				remainingContextTokens: agentContext.maxContextTokens ?? 0,
+				agentId: agentContext.agentId
+			}
+		}, {
+			configurable: { thread_id: this.threadId },
+			metadata: { run_id: compactRunId }
+		});
+		const completedSummaryText = getSummaryText(graph.completedSummary);
+		const contextSummaryText = agentContext.getSummaryText();
+		let summaryText = completedSummaryText;
+		if (summaryText === "" && contextSummaryText != null) summaryText = contextSummaryText;
+		if (summaryText === "") return;
+		const retainedMessages = filterRemoveMessages(summarizedState.messages ?? []);
+		let retainedEntryIds = [];
+		if (retainedMessages.length > 0) retainedEntryIds = messageEntries.slice(-retainedMessages.length).map((entry) => entry.id);
+		const retainedEntryIdSet = new Set(retainedEntryIds);
+		const summarized = messageEntries.filter((entry) => !retainedEntryIdSet.has(entry.id));
+		const summary = await store.appendEntryForCompaction({
+			text: summaryText,
+			tokenCount: getSummaryTokenCount(graph.completedSummary),
+			retainedEntryIds,
+			summarizedEntryIds: summarized.map((entry) => entry.id),
+			instructions: options.instructions,
+			parentId
+		});
+		let retainedParentId = summary.id;
+		for (const message of retainedMessages) retainedParentId = (await store.appendMessage(message, retainedParentId)).id;
+		await store.appendCompactionEntry({
+			summaryEntryId: summary.id,
+			retainedEntryIds,
+			summarizedEntryIds: summarized.map((entry) => entry.id)
+		});
+		return summary;
+	}
+	async resumeInterrupt(resumeValue, options = {}) {
+		const runId = options.runId ?? createRunId();
+		const threadId = options.threadId ?? this.threadId;
+		const isSessionThread = threadId === this.threadId;
+		const baseCallerConfig = createCallerConfig(threadId, options);
+		const callerConfig = applyCheckpointReferenceToConfig(baseCallerConfig, getStoredCheckpointForConfig(this.store, threadId, baseCallerConfig)?.data);
+		await this.store?.appendRunEvent("run.started", void 0, {
+			runId,
+			threadId
+		});
+		const handlerResult = createRunHandlers({
+			runId,
+			threadId,
+			userHandlers: this.runConfig.customHandlers
+		});
+		const sessionState = createSessionRunState(isSessionThread ? this.store?.getPath() ?? [] : []);
+		try {
+			const run = await Run.create({
+				...this.runConfig,
+				runId,
+				graphConfig: applyCheckpointingToGraphConfig(applyInitialSummaryToGraphConfig(this.runConfig.graphConfig, sessionState.initialSummary), this.checkpointing),
+				returnContent: true,
+				calibrationRatio: this.calibrationRatio,
+				customHandlers: {
+					...this.runConfig.customHandlers ?? {},
+					...handlerResult.handlers
+				}
+			});
+			const content = await run.resume(resumeValue, callerConfig);
+			const runMessages = run.getRunMessages() ?? [];
+			if (isSessionThread) for (const message of runMessages) await this.store?.appendMessage(message);
+			this.calibrationRatio = run.getCalibrationRatio();
+			const interrupt = run.getInterrupt();
+			const haltedReason = run.getHaltReason();
+			if (interrupt) await this.store?.appendRunEvent("run.interrupted", interrupt, {
+				runId,
+				threadId
+			});
+			else if (haltedReason != null && haltedReason !== "") await this.store?.appendRunEvent("run.halted", haltedReason, {
+				runId,
+				threadId
+			});
+			else await this.store?.appendRunEvent("run.completed", void 0, {
+				runId,
+				threadId
+			});
+			await this.recordCheckpoint({
+				source: "resume",
+				runId,
+				threadId,
+				config: callerConfig,
+				checkpointId: interrupt?.checkpointId,
+				checkpointNs: interrupt?.checkpointNs
+			});
+			const contentParts = (content ?? handlerResult.contentParts).filter((part) => part != null);
+			return {
+				text: contentToText(contentParts),
+				content: contentParts,
+				messages: runMessages,
+				usage: handlerResult.usage,
+				steps: handlerResult.steps,
+				interrupt,
+				haltedReason,
+				runId,
+				threadId
+			};
+		} catch (error) {
+			await this.store?.appendRunEvent("run.failed", error, {
+				runId,
+				threadId
+			});
+			await this.recordCheckpoint({
+				source: "resume",
+				runId,
+				threadId,
+				config: callerConfig
+			});
+			throw error;
+		}
+	}
+};
 function createAgentSession(config) {
-    return AgentSession.create(config);
+	return AgentSession.create(config);
 }
-
+//#endregion
 export { AgentSession, createAgentSession };
-//# sourceMappingURL=AgentSession.mjs.map
+
+//# sourceMappingURL=AgentSession.mjs.map