agents 0.10.0 → 0.10.2

package/dist/experimental/memory/session/index.js

@@ -1,6 +1,6 @@
 import { MessageType } from "../../../types.js";
 import { m as estimateStringTokens, p as estimateMessageTokens, t as COMPACTION_PREFIX } from "../../../compaction-helpers-BPE1_ziA.js";
-import { jsonSchema } from "ai";
+import { z } from "zod";
 //#region src/experimental/memory/session/search.ts
 /**
 * Check if a provider is a SearchProvider (has a `search` method).
@@ -175,22 +175,6 @@ var R2SkillProvider = class {
 //#endregion
 //#region src/experimental/memory/session/context.ts
 /**
-* Context Block Management
-*
-* Persistent key-value blocks (MEMORY, USER, SOUL, etc.) that are:
-* - Loaded from their providers at init
-* - Frozen into a snapshot when toSystemPrompt() is called
-* - Updated via setBlock() which writes to the provider immediately
-*   but does NOT update the frozen snapshot (preserves LLM prefix cache)
-* - Re-snapshotted on next toSystemPrompt() call
-*
-* Provider type determines behavior:
-* - ContextProvider (get only)        → readonly block in system prompt
-* - WritableContextProvider (get+set) → writable via set_context tool
-* - SkillProvider (get+load+set?)     → metadata in prompt, load_context tool
-* - SearchProvider (get+search+set?)  → searchable via search_context tool
-*/
-/**
 * Check if a provider is writable (has a `set` method).
 */
 function isWritableProvider(provider) {
@@ -204,9 +188,18 @@ var ContextBlocks = class {
 		this.blocks = /* @__PURE__ */ new Map();
 		this.snapshot = null;
 		this.loaded = false;
+		this._loadedSkills = /* @__PURE__ */ new Set();
+		this._onUnloadSkill = null;
 		this.configs = configs;
 		this.promptStore = promptStore ?? null;
 	}
+	/**
+	* Register a callback invoked when a skill is unloaded.
+	* Session uses this to update the stored tool result message.
+	*/
+	setUnloadCallback(cb) {
+		this._onUnloadSkill = cb;
+	}
 	isLoaded() {
 		return this.loaded;
 	}
@@ -235,6 +228,57 @@ var ContextBlocks = class {
 		this.loaded = true;
 	}
 	/**
+	* Dynamically register a new context block after initialization.
+	* Used by extensions to contribute context at runtime.
+	*
+	* If blocks have already been loaded, the new block's provider is
+	* initialized and loaded immediately. The snapshot is NOT updated
+	* automatically — call `refreshSystemPrompt()` to rebuild.
+	*/
+	async addBlock(config) {
+		if (!this.loaded) await this.load();
+		if (this.configs.some((c) => c.label === config.label)) throw new Error(`Block "${config.label}" already exists`);
+		this.configs.push(config);
+		if (config.provider?.init) config.provider.init(config.label);
+		const content = config.provider ? await config.provider.get() ?? "" : "";
+		const skill = config.provider ? isSkillProvider(config.provider) : false;
+		const searchable = config.provider ? isSearchProvider(config.provider) : false;
+		const writable = config.provider ? isWritableProvider(config.provider) || skill && !!config.provider.set || searchable && !!config.provider.set : false;
+		const block = {
+			label: config.label,
+			description: config.description,
+			content,
+			tokens: estimateStringTokens(content),
+			maxTokens: config.maxTokens,
+			writable,
+			isSkill: skill,
+			isSearchable: searchable
+		};
+		this.blocks.set(config.label, block);
+		return block;
+	}
+	/**
+	* Remove a dynamically registered context block.
+	* Used during extension unload cleanup.
+	*
+	* Returns true if the block existed and was removed.
+	* The snapshot is NOT updated automatically — call
+	* `refreshSystemPrompt()` to rebuild.
+	*
+	* Note: loaded skills for this block are cleaned up from the
+	* tracking set but the skill unload callback is NOT fired
+	* (history reclamation is skipped — appropriate for full
+	* extension removal).
+	*/
+	removeBlock(label) {
+		const idx = this.configs.findIndex((c) => c.label === label);
+		if (idx === -1) return false;
+		this.configs.splice(idx, 1);
+		this.blocks.delete(label);
+		for (const id of this._loadedSkills) if (id.startsWith(`${label}:`)) this._loadedSkills.delete(id);
+		return true;
+	}
+	/**
 	* Get a block by label.
 	*/
 	getBlock(label) {
@@ -297,7 +341,39 @@ var ContextBlocks = class {
 		if (!this.loaded) await this.load();
 		const config = this.configs.find((c) => c.label === label);
 		if (!config?.provider || !isSkillProvider(config.provider)) throw new Error(`Block "${label}" is not a skill provider`);
-		return config.provider.load(key);
+		const content = await config.provider.load(key);
+		if (content !== null) this._loadedSkills.add(`${label}:${key}`);
+		return content;
+	}
+	/**
+	* Unload a previously loaded skill. Updates the stored tool result
+	* message via the unload callback (set by Session).
+	*/
+	unloadSkill(label, key) {
+		const id = `${label}:${key}`;
+		if (!this._loadedSkills.has(id)) return false;
+		this._loadedSkills.delete(id);
+		this._onUnloadSkill?.(label, key);
+		return true;
+	}
+	/**
+	* Get the set of currently loaded skill keys (as "label:key" strings).
+	*/
+	getLoadedSkillKeys() {
+		return this._loadedSkills;
+	}
+	/**
+	* Restore loaded skill tracking from a set of "label:key" strings.
+	* Used by Session to reconstruct state after hibernation.
+	*/
+	restoreLoadedSkills(skillIds) {
+		this._loadedSkills = new Set(skillIds);
+	}
+	/**
+	* Clear all loaded skill tracking. Called when messages are cleared.
+	*/
+	clearSkillState() {
+		this._loadedSkills.clear();
 	}
 	/**
 	* Index a search entry within a searchable block.
@@ -474,7 +550,7 @@ var ContextBlocks = class {
 			};
 			toolSet.set_context = {
 				description: `Write to a context block. Available blocks:\n${blockDescriptions.join("\n")}\n\nWrites are durable and persist across sessions.`,
-				inputSchema: jsonSchema({
+				inputSchema: z.fromJSONSchema({
 					type: "object",
 					properties,
 					required
@@ -505,7 +581,7 @@ var ContextBlocks = class {
 			const skillLabels = this.getSkillLabels();
 			toolSet.load_context = {
 				description: "Load a document from a skill block by key. Available skill blocks: " + skillLabels.map((l) => `"${l}"`).join(", ") + ". Check the system prompt for available keys.",
-				inputSchema: jsonSchema({
+				inputSchema: z.fromJSONSchema({
 					type: "object",
 					properties: {
 						label: {
@@ -528,12 +604,35 @@ var ContextBlocks = class {
 					}
 				}
 			};
+			const loadedList = [...this._loadedSkills];
+			toolSet.unload_context = {
+				description: "Unload a previously loaded skill to free context space. The skill remains available for re-loading." + (loadedList.length > 0 ? " Currently loaded: " + loadedList.join(", ") + "." : " No skills currently loaded."),
+				inputSchema: z.fromJSONSchema({
+					type: "object",
+					properties: {
+						label: {
+							type: "string",
+							enum: skillLabels,
+							description: "Skill block label"
+						},
+						key: {
+							type: "string",
+							description: "Skill key to unload"
+						}
+					},
+					required: ["label", "key"]
+				}),
+				execute: async ({ label, key }) => {
+					if (!this.unloadSkill(label, key)) return `Skill "${key}" is not currently loaded in "${label}".`;
+					return `Unloaded "${key}" from ${label}. Context reclaimed.`;
+				}
+			};
 		}
 		if (hasSearch) {
 			const searchLabels = this.getSearchLabels();
 			toolSet.search_context = {
 				description: "Search for information in a searchable context block. Available searchable blocks: " + searchLabels.map((l) => `"${l}"`).join(", ") + ".",
-				inputSchema: jsonSchema({
+				inputSchema: z.fromJSONSchema({
 					type: "object",
 					properties: {
 						label: {
@@ -957,8 +1056,68 @@ var Session = class Session {
 		} else if (this._cachedPrompt) promptStore = this._cachedPrompt;
 		this.storage = new AgentSessionProvider(this._agent, this._sessionId);
 		this.context = new ContextBlocks(configs, promptStore);
+		this.context.setUnloadCallback((label, key) => {
+			this._reclaimLoadedSkill(label, key);
+		});
+		this._restoreLoadedSkills();
 		this._ready = true;
 	}
+	/**
+	* Reconstruct which skills are loaded by scanning conversation history
+	* for load_context tool results that haven't been unloaded.
+	* Called during init to survive hibernation/eviction.
+	*/
+	_restoreLoadedSkills() {
+		const history = this.storage.getHistory();
+		const loaded = /* @__PURE__ */ new Set();
+		for (const msg of history) {
+			if (msg.role !== "assistant") continue;
+			for (const part of msg.parts) if (part.toolName === "load_context" && part.state === "output-available") {
+				const input = part.input;
+				if (input?.label && input?.key) {
+					const id = `${input.label}:${input.key}`;
+					if (typeof part.output === "string" && part.output.startsWith("[skill unloaded:")) loaded.delete(id);
+					else loaded.add(id);
+				}
+			} else if (part.toolName === "unload_context" && part.state === "output-available") {
+				const input = part.input;
+				if (input?.label && input?.key) loaded.delete(`${input.label}:${input.key}`);
+			}
+		}
+		if (loaded.size > 0) this.context.restoreLoadedSkills(loaded);
+	}
+	/**
+	* Replace a load_context tool result in conversation history
+	* with a short marker to reclaim context space.
+	*/
+	_reclaimLoadedSkill(label, key) {
+		const history = this.storage.getHistory();
+		for (let i = history.length - 1; i >= 0; i--) {
+			const msg = history[i];
+			if (msg.role !== "assistant") continue;
+			let changed = false;
+			const newParts = msg.parts.map((part) => {
+				if (part.toolName === "load_context" && part.state === "output-available") {
+					const input = part.input;
+					if (input?.label === label && input?.key === key) {
+						changed = true;
+						return {
+							...part,
+							output: `[skill unloaded: ${key}]`
+						};
+					}
+				}
+				return part;
+			});
+			if (changed) {
+				this.storage.updateMessage({
+					...msg,
+					parts: newParts
+				});
+				return;
+			}
+		}
+	}
 	getHistory(leafId) {
 		this._ensureReady();
 		return this.storage.getHistory(leafId);
@@ -1020,6 +1179,7 @@ var Session = class Session {
 	clearMessages() {
 		this._ensureReady();
 		this.storage.clearMessages();
+		this.context.clearSkillState();
 		this._emitStatus("idle");
 	}
 	addCompaction(summary, fromMessageId, toMessageId) {
@@ -1079,6 +1239,60 @@ var Session = class Session {
 		this._ensureReady();
 		return this.context.appendToBlock(label, content);
 	}
+	/**
+	* Dynamically register a new context block after session initialization.
+	* Used by extensions to contribute context blocks at runtime.
+	*
+	* The block's provider is initialized and loaded immediately.
+	* Call `refreshSystemPrompt()` afterward to include the new block
+	* in the system prompt.
+	*
+	* Note: When called without a provider, auto-wires to SQLite via
+	* AgentContextProvider. Requires the session to have been created
+	* via `Session.create(agent)` (not the direct constructor).
+	*/
+	async addContext(label, options) {
+		this._ensureReady();
+		const opts = options ?? {};
+		let provider = opts.provider;
+		if (!provider) {
+			const key = this._sessionId ? `${label}_${this._sessionId}` : label;
+			provider = new AgentContextProvider(this._agent, key);
+		}
+		return this.context.addBlock({
+			label,
+			description: opts.description,
+			maxTokens: opts.maxTokens,
+			provider
+		});
+	}
+	/**
+	* Remove a dynamically registered context block.
+	* Used during extension unload cleanup.
+	*
+	* Returns true if the block existed and was removed.
+	* Call `refreshSystemPrompt()` afterward to rebuild the prompt
+	* without the removed block.
+	*/
+	removeContext(label) {
+		this._ensureReady();
+		return this.context.removeBlock(label);
+	}
+	/**
+	* Unload a previously loaded skill, reclaiming context space.
+	* The tool result in conversation history is replaced with a short marker.
+	*/
+	unloadSkill(label, key) {
+		this._ensureReady();
+		return this.context.unloadSkill(label, key);
+	}
+	/**
+	* Get currently loaded skill keys (as "label:key" strings).
+	*/
+	getLoadedSkillKeys() {
+		this._ensureReady();
+		return this.context.getLoadedSkillKeys();
+	}
 	async freezeSystemPrompt() {
 		this._ensureReady();
 		return this.context.freezeSystemPrompt();
@@ -1101,14 +1315,12 @@ var Session = class Session {
 //#endregion
 //#region src/experimental/memory/session/manager.ts
 var SessionManager = class SessionManager {
-	constructor(agent, options = {}) {
-		this._maxContextMessages = 100;
+	constructor(agent, _options = {}) {
 		this._pending = [];
 		this._sessions = /* @__PURE__ */ new Map();
 		this._tableReady = false;
 		this._ready = false;
 		this.agent = agent;
-		this._maxContextMessages = options.maxContextMessages ?? 100;
 		this._ready = true;
 		this._ensureTable();
 	}
@@ -1121,7 +1333,7 @@ var SessionManager = class SessionManager {
 	*   .withContext("soul", { provider: { get: async () => "You are helpful." } })
 	*   .withContext("memory", { description: "Learned facts", maxTokens: 1100 })
 	*   .withCachedPrompt()
-	*   .maxContextMessages(50);
+	*   .compactAfter(100_000);
 	*
 	* // Each getSession(id) auto-creates namespaced providers:
 	* //   memory key: "memory_<sessionId>"
@@ -1132,7 +1344,6 @@ var SessionManager = class SessionManager {
 	static create(agent) {
 		const mgr = Object.create(SessionManager.prototype);
 		mgr.agent = agent;
-		mgr._maxContextMessages = 100;
 		mgr._pending = [];
 		mgr._compactionFn = null;
 		mgr._tokenThreshold = void 0;
@@ -1152,10 +1363,6 @@ var SessionManager = class SessionManager {
 		this._cachedPrompt = provider ?? true;
 		return this;
 	}
-	maxContextMessages(count) {
-		this._maxContextMessages = count;
-		return this;
-	}
 	/**
 	* Register a compaction function propagated to all sessions.
 	* Called by `Session.compact()` to compress message history.
@@ -1347,9 +1554,6 @@ var SessionManager = class SessionManager {
 		this._touch(info.id);
 		return info;
 	}
-	needsCompaction(sessionId) {
-		return this.getSession(sessionId).getPathLength() > this._maxContextMessages;
-	}
 	addCompaction(sessionId, summary, fromId, toId) {
 		return this.getSession(sessionId).addCompaction(summary, fromId, toId);
 	}
@@ -1411,7 +1615,7 @@ var SessionManager = class SessionManager {
 	tools() {
 		return { session_search: {
 			description: "Search past conversations for relevant context. Searches across all sessions.",
-			inputSchema: jsonSchema({
+			inputSchema: z.fromJSONSchema({
 				type: "object",
 				properties: { query: {
 					type: "string",