@aigne/core 1.72.0 → 1.74.0-beta

package/dist/prompt/agent-session.cjs

@@ -0,0 +1,700 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils_logger = require('../utils/logger.cjs');
+const require_utils_type_utils = require('../utils/type-utils.cjs');
+const require_utils_token_estimator = require('../utils/token-estimator.cjs');
+const require_types = require('./compact/types.cjs');
+let ufo = require("ufo");
+let yaml = require("yaml");
+let _aigne_uuid = require("@aigne/uuid");
+let _aigne_afs_history = require("@aigne/afs-history");
+
+//#region src/prompt/agent-session.ts
+var AgentSession = class {
+	sessionId;
+	userId;
+	agentId;
+	afs;
+	historyModulePath;
+	mode;
+	compactConfig;
+	sessionMemoryConfig;
+	userMemoryConfig;
+	runtimeState;
+	initialized;
+	compactionPromise;
+	sessionMemoryUpdatePromise;
+	userMemoryUpdatePromise;
+	constructor(options) {
+		this.sessionId = options.sessionId;
+		this.userId = options.userId;
+		this.agentId = options.agentId;
+		this.afs = options.afs;
+		this.mode = options.mode ?? require_types.DEFAULT_SESSION_MODE;
+		this.compactConfig = options.compact ?? {};
+		this.sessionMemoryConfig = options.sessionMemory ?? {};
+		this.userMemoryConfig = options.userMemory ?? {};
+		this.runtimeState = {
+			historyEntries: [],
+			currentEntry: null
+		};
+	}
+	/**
+	* Check if memory extraction is enabled
+	* Memory extraction requires mode to be "auto" AND AFS history module to be available
+	*/
+	get isMemoryEnabled() {
+		return this.mode === "auto" && !!this.afs && !!this.historyModulePath;
+	}
+	async setSystemMessages(...messages) {
+		await this.ensureInitialized();
+		this.runtimeState.systemMessages = messages;
+	}
+	async getMessages() {
+		await this.ensureInitialized();
+		const { systemMessages, userMemory, sessionMemory, historyCompact, historyEntries, currentEntry, currentEntryCompact } = this.runtimeState;
+		let currentMessages = [];
+		if (currentEntry?.messages?.length) if (currentEntryCompact) {
+			const { compressedCount, summary } = currentEntryCompact;
+			currentMessages = [{
+				role: "user",
+				content: `[Earlier messages in this conversation (${compressedCount} messages compressed)]\n${summary}`
+			}, ...currentEntry.messages.slice(compressedCount)];
+		} else currentMessages = currentEntry.messages;
+		const historyMessages = historyEntries.flatMap((entry) => entry.content?.messages ?? []);
+		const hasSkillInCurrentMessages = [...historyMessages, ...currentMessages].some((msg) => msg.role === "user" && Array.isArray(msg.content) && msg.content.some((block) => block.type === "text" && block.isAgentSkill === true));
+		const lastAgentSkillToInject = currentEntryCompact?.lastAgentSkill ?? historyCompact?.lastAgentSkill;
+		return [
+			...systemMessages ?? [],
+			...userMemory && userMemory.length > 0 ? [this.formatUserMemory(userMemory)] : [],
+			...sessionMemory && sessionMemory.length > 0 ? [this.formatSessionMemory(sessionMemory)] : [],
+			...historyCompact?.summary ? [{
+				role: "system",
+				content: `Previous conversation summary:\n${historyCompact.summary}`
+			}] : [],
+			...lastAgentSkillToInject && !hasSkillInCurrentMessages ? [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: lastAgentSkillToInject.content
+				}]
+			}] : [],
+			...historyMessages,
+			...currentMessages
+		].map((msg) => {
+			if (!msg.content || typeof msg.content === "string") return msg;
+			const filteredContent = msg.content.filter((c) => !(c.type === "text" && c.isThinking));
+			if (filteredContent.length === 0) return null;
+			return {
+				...msg,
+				content: filteredContent
+			};
+		}).filter(require_utils_type_utils.isNonNullable).map((msg) => this.truncateLargeMessage(msg));
+	}
+	/**
+	* Format user memory facts into a system message
+	* Applies token budget limit to ensure memory injection fits within constraints
+	*/
+	formatUserMemory(memoryEntries) {
+		const memoryRatio = this.userMemoryConfig.memoryRatio ?? require_types.DEFAULT_MEMORY_RATIO;
+		const maxTokens = Math.floor((this.compactConfig.maxTokens ?? require_types.DEFAULT_MAX_TOKENS) * memoryRatio);
+		const header = "[User Memory Facts]";
+		let currentTokens = require_utils_token_estimator.estimateTokens(header);
+		const facts = [];
+		for (const entry of memoryEntries) {
+			const fact = entry.content?.fact;
+			if (!fact) continue;
+			const factTokens = require_utils_token_estimator.estimateTokens(fact);
+			if (currentTokens + factTokens > maxTokens) break;
+			facts.push(fact);
+			currentTokens += factTokens;
+		}
+		return {
+			role: "system",
+			content: this.formatMemoryTemplate({
+				header,
+				data: facts
+			})
+		};
+	}
+	/**
+	* Format session memory facts into a system message
+	* Applies token budget limit to ensure memory injection fits within constraints
+	*/
+	formatSessionMemory(memoryEntries) {
+		const memoryRatio = this.sessionMemoryConfig.memoryRatio ?? require_types.DEFAULT_MEMORY_RATIO;
+		const maxTokens = Math.floor((this.compactConfig.maxTokens ?? require_types.DEFAULT_MAX_TOKENS) * memoryRatio);
+		const header = "[Session Memory Facts]";
+		let currentTokens = require_utils_token_estimator.estimateTokens(header);
+		const facts = [];
+		for (const entry of memoryEntries) {
+			const fact = entry.content?.fact;
+			if (!fact) continue;
+			const factTokens = require_utils_token_estimator.estimateTokens(fact);
+			if (currentTokens + factTokens > maxTokens) break;
+			facts.push(fact);
+			currentTokens += factTokens;
+		}
+		return {
+			role: "system",
+			content: this.formatMemoryTemplate({
+				header,
+				data: facts
+			})
+		};
+	}
+	formatMemoryTemplate({ header, data }) {
+		return `\
+${header}
+
+\`\`\`yaml
+${(0, yaml.stringify)(data)}
+\`\`\`
+`;
+	}
+	async startMessage(input, message, options) {
+		await this.ensureInitialized();
+		if (this.mode !== "disabled") {
+			await this.maybeAutoCompact(options);
+			if (this.compactionPromise) await this.compactionPromise;
+		}
+		this.runtimeState.currentEntryCompact = void 0;
+		this.runtimeState.currentEntry = {
+			input,
+			messages: [message]
+		};
+	}
+	async endMessage(output, message, options) {
+		await this.ensureInitialized();
+		if (!this.runtimeState.currentEntry?.input || !this.runtimeState.currentEntry.messages?.length) throw new Error("No current entry to end. Call startMessage() first.");
+		if (message) this.runtimeState.currentEntry.messages.push(message);
+		this.runtimeState.currentEntry.output = output;
+		let newEntry;
+		if (this.mode !== "disabled" && this.afs && this.historyModulePath) newEntry = (await this.afs.write((0, ufo.joinURL)(this.historyModulePath, "by-session", this.sessionId, "new"), {
+			userId: this.userId,
+			sessionId: this.sessionId,
+			agentId: this.agentId,
+			content: this.runtimeState.currentEntry
+		})).data;
+		else {
+			const id = (0, _aigne_uuid.v7)();
+			newEntry = {
+				id,
+				path: `/history/${id}`,
+				userId: this.userId,
+				sessionId: this.sessionId,
+				agentId: this.agentId,
+				content: this.runtimeState.currentEntry
+			};
+		}
+		this.runtimeState.historyEntries.push(newEntry);
+		this.runtimeState.currentEntry = null;
+		this.runtimeState.currentEntryCompact = void 0;
+		if (this.mode !== "disabled") await Promise.all([this.maybeAutoCompact(options), this.maybeAutoUpdateSessionMemory(options)]);
+	}
+	/**
+	* Manually trigger compaction
+	*/
+	async compact(options) {
+		await this.ensureInitialized();
+		if (this.compactionPromise) return this.compactionPromise;
+		this.compactionPromise = this.doCompact(options).finally(() => {
+			this.compactionPromise = void 0;
+		});
+		if (!(this.compactConfig.async ?? require_types.DEFAULT_COMPACT_ASYNC)) await this.compactionPromise;
+	}
+	/**
+	* Internal method that performs the actual compaction
+	*/
+	async doCompact(options) {
+		const { compactor } = this.compactConfig ?? {};
+		if (!compactor) throw new Error("Cannot compact without a compactor agent configured.");
+		const historyEntries = this.runtimeState.historyEntries;
+		if (historyEntries.length === 0) return;
+		const maxTokens = this.maxTokens;
+		const keepRecentTokens = this.keepRecentTokens * .5;
+		let splitIndex = historyEntries.length;
+		let accumulatedTokens = 0;
+		for (let i = historyEntries.length - 1; i >= 0; i--) {
+			const entry = historyEntries[i];
+			if (!entry) continue;
+			const entryTokens = this.estimateMessagesTokens(entry.content?.messages ?? []);
+			if (accumulatedTokens + entryTokens > keepRecentTokens) {
+				splitIndex = i + 1;
+				break;
+			}
+			accumulatedTokens += entryTokens;
+			splitIndex = i;
+		}
+		const entriesToCompact = historyEntries.slice(0, splitIndex);
+		const entriesToKeep = historyEntries.slice(splitIndex);
+		if (entriesToCompact.length === 0) return;
+		const latestCompactedEntry = entriesToCompact.at(-1);
+		if (!latestCompactedEntry) return;
+		const batches = this.splitIntoBatches(entriesToCompact, maxTokens);
+		let currentSummary = this.runtimeState.historyCompact?.summary;
+		for (const batch of batches) {
+			const messages = batch.flatMap((e) => e.content?.messages ?? []).filter(require_utils_type_utils.isNonNullable).map((msg) => this.truncateLargeMessage(msg));
+			currentSummary = (await options.context.invoke(compactor, {
+				previousSummary: [currentSummary].filter(require_utils_type_utils.isNonNullable),
+				messages
+			})).summary;
+		}
+		let lastAgentSkill = this.findLastAgentSkill(entriesToCompact);
+		if (!lastAgentSkill && this.runtimeState.historyCompact?.lastAgentSkill) lastAgentSkill = this.runtimeState.historyCompact.lastAgentSkill;
+		const historyCompact = {
+			summary: currentSummary ?? "",
+			lastAgentSkill
+		};
+		if (this.afs && this.historyModulePath) await this.afs.write((0, ufo.joinURL)(this.historyModulePath, "by-session", this.sessionId, "@metadata/compact/new"), {
+			userId: this.userId,
+			agentId: this.agentId,
+			content: historyCompact,
+			metadata: { latestEntryId: latestCompactedEntry.id }
+		});
+		this.runtimeState.historyCompact = historyCompact;
+		this.runtimeState.historyEntries = entriesToKeep;
+	}
+	async compactCurrentEntry(options) {
+		const { compactor } = this.compactConfig ?? {};
+		if (!compactor) return;
+		const currentEntry = this.runtimeState.currentEntry;
+		if (!currentEntry?.messages?.length) return;
+		const alreadyCompressedCount = this.runtimeState.currentEntryCompact?.compressedCount ?? 0;
+		const uncompressedMessages = currentEntry.messages.slice(alreadyCompressedCount);
+		if (uncompressedMessages.length === 0) return;
+		const keepTokenBudget = this.keepRecentTokens * .5;
+		let splitIndex = uncompressedMessages.length;
+		let accumulatedTokens = 0;
+		for (let i = uncompressedMessages.length - 1; i >= 0; i--) {
+			const msg = uncompressedMessages[i];
+			if (!msg) continue;
+			const msgTokens = this.estimateMessagesTokens([msg]);
+			if (accumulatedTokens + msgTokens > keepTokenBudget) {
+				splitIndex = i + 1;
+				break;
+			}
+			accumulatedTokens += msgTokens;
+			splitIndex = i;
+		}
+		const keptMessages = uncompressedMessages.slice(splitIndex);
+		const requiredToolCallIds = /* @__PURE__ */ new Set();
+		for (const msg of keptMessages) if (msg.role === "tool" && msg.toolCallId) requiredToolCallIds.add(msg.toolCallId);
+		if (requiredToolCallIds.size > 0) for (let i = splitIndex - 1; i >= 0; i--) {
+			const msg = uncompressedMessages[i];
+			if (!msg?.toolCalls) continue;
+			for (const toolCall of msg.toolCalls) if (requiredToolCallIds.has(toolCall.id)) {
+				splitIndex = i;
+				break;
+			}
+		}
+		const messagesToCompact = uncompressedMessages.slice(0, splitIndex).map((msg) => this.truncateLargeMessage(msg));
+		if (messagesToCompact.length === 0) return;
+		const result = await options.context.invoke(compactor, {
+			previousSummary: this.runtimeState.currentEntryCompact?.summary ? [this.runtimeState.currentEntryCompact.summary] : void 0,
+			messages: messagesToCompact
+		});
+		const lastAgentSkill = this.findLastAgentSkillFromMessages(messagesToCompact) ?? this.runtimeState.currentEntryCompact?.lastAgentSkill;
+		this.runtimeState.currentEntryCompact = {
+			summary: result.summary,
+			lastAgentSkill,
+			compressedCount: alreadyCompressedCount + messagesToCompact.length
+		};
+	}
+	async maybeCompactCurrentEntry(options) {
+		const currentEntry = this.runtimeState.currentEntry;
+		if (!currentEntry?.messages?.length) return;
+		const compressedCount = this.runtimeState.currentEntryCompact?.compressedCount ?? 0;
+		const uncompressedMessages = currentEntry.messages.slice(compressedCount);
+		const threshold = this.keepRecentTokens;
+		if (this.estimateMessagesTokens(uncompressedMessages) > threshold) await this.compactCurrentEntry(options);
+	}
+	async maybeAutoCompact(options) {
+		if (this.compactionPromise) await this.compactionPromise;
+		if ((this.compactConfig.mode ?? require_types.DEFAULT_COMPACT_MODE) === "disabled") return;
+		const { compactor } = this.compactConfig;
+		if (!compactor) return;
+		const maxTokens = this.maxTokens;
+		const messages = await this.getMessages();
+		if (this.estimateMessagesTokens(messages) >= maxTokens) await this.compact(options);
+	}
+	/**
+	* Estimate token count for messages
+	* Applies singleMessageLimit to each text block individually
+	* Non-text tokens (images, tool calls) are always counted in full
+	*/
+	estimateMessagesTokens(messages, singleMessageLimit = this.singleMessageLimit) {
+		let totalTokens = 0;
+		for (const msg of messages) {
+			if (typeof msg.content === "string") {
+				const textTokens = require_utils_token_estimator.estimateTokens(msg.content);
+				totalTokens += textTokens > singleMessageLimit ? singleMessageLimit : textTokens;
+			} else if (Array.isArray(msg.content)) for (const block of msg.content) if (block.type === "text" && typeof block.text === "string") {
+				const textTokens = require_utils_token_estimator.estimateTokens(block.text);
+				totalTokens += textTokens > singleMessageLimit ? singleMessageLimit : textTokens;
+			} else totalTokens += 1e3;
+			if (msg.toolCalls && msg.toolCalls.length > 0) for (const toolCall of msg.toolCalls) {
+				totalTokens += require_utils_token_estimator.estimateTokens(toolCall.function.name);
+				totalTokens += require_utils_token_estimator.estimateTokens((0, yaml.stringify)(toolCall.function.arguments).replace(/\s+/g, " "));
+				totalTokens += 10;
+			}
+		}
+		return totalTokens;
+	}
+	/**
+	* Split entries into batches based on token limit
+	* Each batch will not exceed the specified maxTokens
+	*/
+	splitIntoBatches(entries, maxTokens) {
+		const batches = [];
+		let currentBatch = [];
+		let currentTokens = 0;
+		for (const entry of entries) {
+			const entryTokens = this.estimateMessagesTokens(entry.content?.messages ?? []);
+			if (currentTokens + entryTokens > maxTokens && currentBatch.length > 0) {
+				batches.push(currentBatch);
+				currentBatch = [entry];
+				currentTokens = entryTokens;
+			} else {
+				currentBatch.push(entry);
+				currentTokens += entryTokens;
+			}
+		}
+		if (currentBatch.length > 0) batches.push(currentBatch);
+		return batches;
+	}
+	async appendCurrentMessages(messages, options) {
+		await this.ensureInitialized();
+		if (!this.runtimeState.currentEntry || !this.runtimeState.currentEntry.messages?.length) throw new Error("No current entry to append messages. Call startMessage() first.");
+		this.runtimeState.currentEntry.messages.push(...[messages].flat());
+		await this.maybeCompactCurrentEntry(options);
+	}
+	/**
+	* Truncate text content to fit within target token limit
+	* @param text The text to truncate
+	* @param currentTokens Current token count of the text
+	* @param targetTokens Target token count after truncation
+	* @returns Truncated text
+	*/
+	truncateText(text, currentTokens, targetTokens) {
+		if (currentTokens <= targetTokens) return text;
+		const keepRatio = targetTokens / currentTokens * .9;
+		const keepLength = Math.floor(text.length * keepRatio);
+		const headLength = Math.floor(keepLength * .7);
+		const tailLength = Math.floor(keepLength * .3);
+		return text.slice(0, headLength) + `\n\n[... truncated ${currentTokens - targetTokens} tokens ...]\n\n` + text.slice(-tailLength);
+	}
+	truncateLargeMessage(msg) {
+		const singleMessageLimit = this.singleMessageLimit;
+		if (typeof msg.content === "string") {
+			const tokens = require_utils_token_estimator.estimateTokens(msg.content);
+			if (tokens <= singleMessageLimit) return msg;
+			const truncated = this.truncateText(msg.content, tokens, singleMessageLimit);
+			return {
+				...msg,
+				content: truncated
+			};
+		}
+		if (Array.isArray(msg.content)) {
+			const truncatedContent = msg.content.map((block) => {
+				if (block.type !== "text" || typeof block.text !== "string") return block;
+				const blockTokens = require_utils_token_estimator.estimateTokens(block.text);
+				if (blockTokens <= singleMessageLimit) return block;
+				const truncatedText = this.truncateText(block.text, blockTokens, singleMessageLimit);
+				return {
+					...block,
+					text: truncatedText
+				};
+			});
+			return {
+				...msg,
+				content: truncatedContent
+			};
+		}
+		return msg;
+	}
+	async ensureInitialized() {
+		this.initialized ??= this.initialize();
+		await this.initialized;
+	}
+	async initialize() {
+		if (this.initialized) return;
+		await this.initializeDefaultCompactor();
+		await this.initializeDefaultSessionMemoryExtractor();
+		await this.initializeDefaultUserMemoryExtractor();
+		this.historyModulePath = ((await this.afs?.listModules())?.find((m) => m.module instanceof _aigne_afs_history.AFSHistory))?.path;
+		if (this.afs && this.historyModulePath) {
+			const [userMemory, sessionMemory, sessionHistory] = await Promise.all([
+				this.loadUserMemory(),
+				this.loadSessionMemory(),
+				this.loadSessionHistory()
+			]);
+			this.runtimeState.userMemory = userMemory;
+			this.runtimeState.sessionMemory = sessionMemory;
+			this.runtimeState.historyCompact = sessionHistory.historyCompact;
+			this.runtimeState.historyEntries = sessionHistory.historyEntries;
+		}
+	}
+	/**
+	* Load session memory facts
+	* @returns Array of memory fact entries for the current session
+	*/
+	async loadSessionMemory() {
+		if (!this.afs || !this.historyModulePath) return [];
+		if ((this.sessionMemoryConfig.mode ?? require_types.DEFAULT_SESSION_MEMORY_MODE) === "disabled") return [];
+		const sessionMemoryPath = (0, ufo.joinURL)(this.historyModulePath, "by-session", this.sessionId, "@metadata/memory");
+		const queryLimit = this.sessionMemoryConfig.queryLimit ?? require_types.DEFAULT_MEMORY_QUERY_LIMIT;
+		return (await this.afs.list(sessionMemoryPath, {
+			filter: {
+				userId: this.userId,
+				agentId: this.agentId
+			},
+			orderBy: [["updatedAt", "desc"]],
+			limit: queryLimit
+		})).data.reverse().filter((entry) => require_utils_type_utils.isNonNullable(entry.content));
+	}
+	/**
+	* Load user memory facts
+	* @returns Array of memory fact entries for the current user
+	*/
+	async loadUserMemory() {
+		if (!this.afs || !this.historyModulePath || !this.userId) return [];
+		if ((this.userMemoryConfig.mode ?? require_types.DEFAULT_USER_MEMORY_MODE) === "disabled") return [];
+		const userMemoryPath = (0, ufo.joinURL)(this.historyModulePath, "by-user", this.userId, "@metadata/memory");
+		const queryLimit = this.userMemoryConfig.queryLimit ?? require_types.DEFAULT_MEMORY_QUERY_LIMIT;
+		return (await this.afs.list(userMemoryPath, {
+			filter: {
+				userId: this.userId,
+				agentId: this.agentId
+			},
+			orderBy: [["updatedAt", "desc"]],
+			limit: queryLimit
+		})).data.reverse().filter((entry) => require_utils_type_utils.isNonNullable(entry.content));
+	}
+	/**
+	* Load session history including compact content and history entries
+	* @returns Object containing history compact and history entries
+	*/
+	async loadSessionHistory() {
+		if (!this.afs || !this.historyModulePath) return { historyEntries: [] };
+		const compactPath = (0, ufo.joinURL)(this.historyModulePath, "by-session", this.sessionId, "@metadata/compact");
+		const latestCompact = (await this.afs.list(compactPath, {
+			filter: {
+				userId: this.userId,
+				agentId: this.agentId
+			},
+			orderBy: [["createdAt", "desc"]],
+			limit: 1
+		})).data[0];
+		return {
+			historyCompact: latestCompact?.content,
+			historyEntries: (await this.afs.list((0, ufo.joinURL)(this.historyModulePath, "by-session", this.sessionId), {
+				filter: {
+					userId: this.userId,
+					agentId: this.agentId,
+					after: latestCompact?.createdAt?.toISOString()
+				},
+				orderBy: [["createdAt", "desc"]],
+				limit: 1e4
+			})).data.reverse().filter((entry) => require_utils_type_utils.isNonNullable(entry.content))
+		};
+	}
+	/**
+	* Manually trigger session memory update
+	*/
+	async updateSessionMemory(options) {
+		await this.ensureInitialized();
+		this.sessionMemoryUpdatePromise ??= this.doUpdateSessionMemory(options).then(() => {
+			this.maybeAutoUpdateUserMemory(options).catch((err) => {
+				require_utils_logger.logger.error("User memory update failed:", err);
+			});
+		}).finally(() => {
+			this.sessionMemoryUpdatePromise = void 0;
+		});
+		return this.sessionMemoryUpdatePromise;
+	}
+	async maybeAutoUpdateSessionMemory(options) {
+		if (!this.isMemoryEnabled) return;
+		if ((this.sessionMemoryConfig.mode ?? require_types.DEFAULT_SESSION_MEMORY_MODE) === "disabled") return;
+		this.updateSessionMemory(options).catch((err) => {
+			require_utils_logger.logger.error("Session memory update failed:", err);
+		});
+		if (!(this.sessionMemoryConfig.async ?? require_types.DEFAULT_SESSION_MEMORY_ASYNC)) await this.sessionMemoryUpdatePromise;
+	}
+	async maybeAutoUpdateUserMemory(options) {
+		if (!this.isMemoryEnabled || !this.userId) return;
+		if ((this.userMemoryConfig.mode ?? require_types.DEFAULT_USER_MEMORY_MODE) === "disabled") return;
+		this.updateUserMemory(options).catch((err) => {
+			require_utils_logger.logger.error("User memory update failed:", err);
+		});
+		if (!(this.userMemoryConfig.async ?? require_types.DEFAULT_USER_MEMORY_ASYNC)) await this.userMemoryUpdatePromise;
+	}
+	/**
+	* Internal method that performs the actual session memory update
+	*/
+	async doUpdateSessionMemory(options) {
+		const { extractor } = this.sessionMemoryConfig ?? {};
+		if (!extractor) throw new Error("Cannot update session memory without an extractor agent configured.");
+		const latestEntryId = this.runtimeState.sessionMemory?.at(-1)?.metadata?.latestEntryId;
+		const lastExtractedIndex = latestEntryId ? this.runtimeState.historyEntries.findIndex((e) => e.id === latestEntryId) : -1;
+		const unextractedEntries = lastExtractedIndex >= 0 ? this.runtimeState.historyEntries.slice(lastExtractedIndex + 1) : this.runtimeState.historyEntries;
+		if (unextractedEntries.length === 0) return;
+		const recentMessages = unextractedEntries.flatMap((entry) => entry.content?.messages ?? []).filter(require_utils_type_utils.isNonNullable);
+		if (recentMessages.length === 0) return;
+		const existingFacts = this.runtimeState.sessionMemory?.map((entry) => entry.content).filter(require_utils_type_utils.isNonNullable) ?? [];
+		const existingUserFacts = this.runtimeState.userMemory?.map((entry) => entry.content).filter(require_utils_type_utils.isNonNullable) ?? [];
+		const result = await options.context.invoke(extractor, {
+			existingUserFacts,
+			existingFacts,
+			messages: recentMessages
+		});
+		if (!result.newFacts.length && !result.removeFacts?.length) return;
+		const latestExtractedEntry = unextractedEntries.at(-1);
+		if (this.afs && this.historyModulePath) {
+			if (result.removeFacts?.length && this.runtimeState.sessionMemory) {
+				const entriesToRemove = [];
+				for (const label of result.removeFacts) {
+					const entry = this.runtimeState.sessionMemory.find((e) => e.content?.label === label);
+					if (entry) entriesToRemove.push(entry);
+				}
+				for (const entryToRemove of entriesToRemove) {
+					const memoryEntryPath = (0, ufo.joinURL)(this.historyModulePath, "by-session", this.sessionId, "@metadata/memory", entryToRemove.id);
+					await this.afs.delete(memoryEntryPath);
+					const index = this.runtimeState.sessionMemory.indexOf(entryToRemove);
+					if (index !== -1) this.runtimeState.sessionMemory.splice(index, 1);
+				}
+			}
+			if (result.newFacts.length) {
+				const sessionMemoryPath = (0, ufo.joinURL)(this.historyModulePath, "by-session", this.sessionId, "@metadata/memory/new");
+				for (const fact of result.newFacts) {
+					const newEntry = await this.afs.write(sessionMemoryPath, {
+						userId: this.userId,
+						sessionId: this.sessionId,
+						agentId: this.agentId,
+						content: fact,
+						metadata: { latestEntryId: latestExtractedEntry?.id }
+					});
+					this.runtimeState.sessionMemory ??= [];
+					this.runtimeState.sessionMemory.push(newEntry.data);
+				}
+			}
+		}
+	}
+	/**
+	* Manually trigger user memory update
+	*/
+	async updateUserMemory(options) {
+		await this.ensureInitialized();
+		this.userMemoryUpdatePromise ??= this.doUpdateUserMemory(options).finally(() => {
+			this.userMemoryUpdatePromise = void 0;
+		});
+		return this.userMemoryUpdatePromise;
+	}
+	/**
+	* Internal method that performs the actual user memory extraction
+	*/
+	async doUpdateUserMemory(options) {
+		const { extractor } = this.userMemoryConfig ?? {};
+		if (!extractor) throw new Error("Cannot update user memory without an extractor agent configured.");
+		const sessionFacts = this.runtimeState.sessionMemory?.map((entry) => entry.content).filter(require_utils_type_utils.isNonNullable) ?? [];
+		if (sessionFacts.length === 0) return;
+		const existingUserFacts = this.runtimeState.userMemory?.map((entry) => entry.content).filter(require_utils_type_utils.isNonNullable) ?? [];
+		const result = await options.context.invoke(extractor, {
+			sessionFacts,
+			existingUserFacts
+		});
+		if (!result.newFacts.length && !result.removeFacts?.length) return;
+		if (this.afs && this.historyModulePath && this.userId) {
+			if (result.removeFacts?.length && this.runtimeState.userMemory) {
+				const entriesToRemove = [];
+				for (const label of result.removeFacts) {
+					const entry = this.runtimeState.userMemory.find((e) => e.content?.label === label);
+					if (entry) entriesToRemove.push(entry);
+				}
+				for (const entryToRemove of entriesToRemove) {
+					const memoryEntryPath = (0, ufo.joinURL)(this.historyModulePath, "by-user", this.userId, "@metadata/memory", entryToRemove.id);
+					await this.afs.delete(memoryEntryPath);
+					const index = this.runtimeState.userMemory.indexOf(entryToRemove);
+					if (index !== -1) this.runtimeState.userMemory.splice(index, 1);
+				}
+			}
+			if (result.newFacts.length) {
+				const userMemoryPath = (0, ufo.joinURL)(this.historyModulePath, "by-user", this.userId, "@metadata/memory/new");
+				for (const fact of result.newFacts) {
+					const existingEntry = this.runtimeState.userMemory?.find((e) => e.content?.label === fact.label);
+					if (existingEntry) {
+						const oldEntryPath = (0, ufo.joinURL)(this.historyModulePath, "by-user", this.userId, "@metadata/memory", existingEntry.id);
+						await this.afs.delete(oldEntryPath);
+						if (this.runtimeState.userMemory) {
+							const index = this.runtimeState.userMemory.indexOf(existingEntry);
+							if (index !== -1) this.runtimeState.userMemory.splice(index, 1);
+						}
+					}
+					const newEntry = await this.afs.write(userMemoryPath, {
+						userId: this.userId,
+						agentId: this.agentId,
+						content: fact
+					});
+					this.runtimeState.userMemory ??= [];
+					this.runtimeState.userMemory.push(newEntry.data);
+				}
+			}
+		}
+	}
+	/**
+	* Find Agent Skill content from a single message
+	* @param msg - Message to search in
+	* @returns The skill content text if found, undefined otherwise
+	*/
+	findSkillContentInMessage(msg) {
+		if (msg.role === "user" && Array.isArray(msg.content)) {
+			const skillBlock = msg.content.find((block) => block.type === "text" && block.isAgentSkill === true);
+			if (skillBlock && skillBlock.type === "text") return skillBlock.text;
+		}
+	}
+	/**
+	* Find the last Agent Skill from a list of messages
+	* @param messages - Messages to search through
+	* @returns The last Agent Skill found, or undefined if none found
+	*/
+	findLastAgentSkillFromMessages(messages) {
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const msg = messages[i];
+			if (!msg) continue;
+			const skillContent = this.findSkillContentInMessage(msg);
+			if (skillContent) return { content: skillContent };
+		}
+	}
+	/**
+	* Find the last Agent Skill from a list of history entries
+	* @param entries - History entries to search through
+	* @returns The last Agent Skill found, or undefined if none found
+	*/
+	findLastAgentSkill(entries) {
+		const allMessages = entries.flatMap((entry) => entry.content?.messages ?? []);
+		return this.findLastAgentSkillFromMessages(allMessages);
+	}
+	async initializeDefaultCompactor() {
+		this.compactConfig.compactor ??= await Promise.resolve().then(() => require("./compact/compactor.cjs")).then((m) => new m.AISessionCompactor());
+	}
+	async initializeDefaultSessionMemoryExtractor() {
+		this.sessionMemoryConfig.extractor ??= await Promise.resolve().then(() => require("./compact/session-memory-extractor.cjs")).then((m) => new m.AISessionMemoryExtractor());
+	}
+	async initializeDefaultUserMemoryExtractor() {
+		this.userMemoryConfig.extractor ??= await Promise.resolve().then(() => require("./compact/user-memory-extractor.cjs")).then((m) => new m.AIUserMemoryExtractor());
+	}
+	get maxTokens() {
+		return this.compactConfig?.maxTokens ?? require_types.DEFAULT_MAX_TOKENS;
+	}
+	get keepRecentRatio() {
+		return this.compactConfig?.keepRecentRatio ?? require_types.DEFAULT_KEEP_RECENT_RATIO;
+	}
+	get keepRecentTokens() {
+		return Math.floor(this.maxTokens * this.keepRecentRatio);
+	}
+	get singleMessageLimit() {
+		return this.keepRecentTokens * .5;
+	}
+};
+
+//#endregion
+exports.AgentSession = AgentSession;