@librechat/agents 3.1.85 → 3.1.87

package/dist/cjs/session/AgentSession.cjs

@@ -0,0 +1,1057 @@
+'use strict';
+
+var langgraph = require('@langchain/langgraph');
+var messages = require('@langchain/core/messages');
+var AgentContext = require('../agents/AgentContext.cjs');
+var _enum = require('../common/enum.cjs');
+var run = require('../run.cjs');
+var ids = require('./ids.cjs');
+var messageSerialization = require('./messageSerialization.cjs');
+var JsonlSessionStore = require('./JsonlSessionStore.cjs');
+var handlers = require('./handlers.cjs');
+var node = require('../summarization/node.cjs');
+
+function isBaseMessage(value) {
+    return (value instanceof messages.BaseMessage ||
+        (value != null &&
+            typeof value === 'object' &&
+            '_getType' in value &&
+            typeof value._getType === 'function'));
+}
+function normalizeInput(input) {
+    if (typeof input === 'string') {
+        const messages$1 = [new messages.HumanMessage(input)];
+        return { messages: messages$1, state: { messages: messages$1 } };
+    }
+    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 };
+}
+function contentToText(content) {
+    const chunks = [];
+    for (const part of content) {
+        if (!part) {
+            continue;
+        }
+        if (part.type === _enum.ContentTypes.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 ?? ids.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;
+}
+async function createStore(params) {
+    if (params.ephemeral === true) {
+        return undefined;
+    }
+    if (params.sessionPath != null && params.sessionPath !== '') {
+        try {
+            return await JsonlSessionStore.JsonlSessionStore.openPath(params.sessionPath);
+        }
+        catch (error) {
+            if (!isMissingSessionError(error)) {
+                throw error;
+            }
+            return JsonlSessionStore.JsonlSessionStore.create({
+                path: params.sessionPath,
+                cwd: params.cwd,
+                name: params.name,
+                sessionId: params.sessionId,
+            });
+        }
+    }
+    return JsonlSessionStore.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,
+    };
+}
+function applyInitialSummaryToAgent(agent, initialSummary) {
+    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),
+    };
+}
+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');
+}
+function getGraphCheckpointer(graphConfig) {
+    const checkpointer = graphConfig.compileOptions?.checkpointer;
+    return isCheckpointSaver(checkpointer) ? checkpointer : undefined;
+}
+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 langgraph.MemorySaver(),
+        };
+    }
+    if (checkpointing === true || runConfig.humanInTheLoop?.enabled === true) {
+        return {
+            enabled: true,
+            checkpointer: graphCheckpointer ?? new langgraph.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,
+    };
+}
+function applyCheckpointerToGraphConfig(graphConfig, 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);
+}
+function getConfigString(config, key) {
+    const configurable = config?.configurable;
+    const value = configurable?.[key];
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+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;
+}
+function createCallerConfig(threadId, options) {
+    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 } : {}),
+        },
+    };
+}
+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 ?? '',
+        },
+    };
+}
+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;
+}
+function createLatestCheckpointLookupConfig(config) {
+    const lookup = createCheckpointLookupConfig(config);
+    const { checkpoint_id: _checkpointId, ...configurable } = lookup.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;
+}
+async function getSelectedCheckpointTuple(checkpointer, 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 } : {}),
+    };
+}
+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(messageSerialization.deserializeMessage(entry.data.message));
+        }
+    }
+    return { messages, initialSummary };
+}
+function isMessageEntry(entry) {
+    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);
+}
+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);
+}
+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,
+    };
+}
+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?.[_enum.GraphEvents.ON_RUN_STEP]?.handle(_enum.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?.[_enum.GraphEvents.ON_RUN_STEP_COMPLETED]?.handle(_enum.GraphEvents.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
+        : '';
+}
+function getSummaryTokenCount(summary) {
+    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 ?? ids.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 ?? ids.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 = handlers.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$1 = await run.Run.create(runConfig);
+            let messages = inputMessages;
+            if (!useCheckpointState && sessionState.messages.length > 0) {
+                messages = sessionState.messages;
+            }
+            const content = await run$1.processStream({ ...normalizedInput.state, messages }, callerConfig, options.streamOptions);
+            const runMessages = run$1.getRunMessages() ?? [];
+            if (isSessionThread) {
+                for (const message of runMessages) {
+                    await this.store?.appendMessage(message);
+                }
+            }
+            this.calibrationRatio = run$1.getCalibrationRatio();
+            const interrupt = run$1.getInterrupt();
+            const haltedReason = run$1.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.JsonlSessionStore.list(this.cwd);
+            if (sessions.length === 0) {
+                throw new Error(`No sessions found for ${this.cwd}`);
+            }
+            this.store = await JsonlSessionStore.JsonlSessionStore.open(sessions[0].path);
+            this.cwd = this.store.header.cwd;
+            this.threadId = this.store.header.id;
+            return this;
+        }
+        this.store = await JsonlSessionStore.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 = ids.createRunId();
+        const agentContext = 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 = node.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 ?? ids.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 = handlers.createRunHandlers({
+            runId,
+            threadId,
+            userHandlers: this.runConfig.customHandlers,
+        });
+        const sessionState = createSessionRunState(isSessionThread ? (this.store?.getPath() ?? []) : []);
+        try {
+            const run$1 = await run.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$1.resume(resumeValue, callerConfig);
+            const runMessages = run$1.getRunMessages() ?? [];
+            if (isSessionThread) {
+                for (const message of runMessages) {
+                    await this.store?.appendMessage(message);
+                }
+            }
+            this.calibrationRatio = run$1.getCalibrationRatio();
+            const interrupt = run$1.getInterrupt();
+            const haltedReason = run$1.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;
+        }
+    }
+}
+function createAgentSession(config) {
+    return AgentSession.create(config);
+}
+
+exports.AgentSession = AgentSession;
+exports.createAgentSession = createAgentSession;
+//# sourceMappingURL=AgentSession.cjs.map