agents 0.8.7 → 0.10.0

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

@@ -1,6 +1,178 @@
 import { MessageType } from "../../../types.js";
-import { m as estimateStringTokens, p as estimateMessageTokens, t as COMPACTION_PREFIX } from "../../../compaction-helpers-BFTBIzpK.js";
+import { m as estimateStringTokens, p as estimateMessageTokens, t as COMPACTION_PREFIX } from "../../../compaction-helpers-BPE1_ziA.js";
 import { jsonSchema } from "ai";
+//#region src/experimental/memory/session/search.ts
+/**
+* Check if a provider is a SearchProvider (has a `search` method).
+*/
+function isSearchProvider(provider) {
+	return typeof provider === "object" && provider !== null && "search" in provider && typeof provider.search === "function";
+}
+/**
+* SearchProvider backed by Durable Object SQLite with FTS5.
+*
+* - `get()` returns a count of indexed entries
+* - `search(query)` full-text search using FTS5
+* - `set(key, content)` indexes or replaces content under a key
+*
+* Each instance uses a namespaced FTS5 table to avoid collisions
+* with the session message search.
+*
+* @example
+* ```ts
+* Session.create(this)
+*   .withContext("knowledge", {
+*     provider: new AgentSearchProvider(this)
+*   })
+* ```
+*/
+var AgentSearchProvider = class {
+	constructor(agent) {
+		this.label = "";
+		this.initialized = false;
+		this.agent = agent;
+	}
+	init(label) {
+		this.label = label;
+	}
+	ensureTable() {
+		if (this.initialized) return;
+		this.agent.sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_search_entries (
+        label TEXT NOT NULL,
+        key TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (label, key)
+      )
+    `;
+		this.agent.sql`
+      CREATE VIRTUAL TABLE IF NOT EXISTS cf_agents_search_fts
+      USING fts5(
+        label UNINDEXED,
+        key UNINDEXED,
+        content,
+        tokenize='porter unicode61'
+      )
+    `;
+		this.initialized = true;
+	}
+	async get() {
+		this.ensureTable();
+		const count = this.agent.sql`
+      SELECT COUNT(*) as count FROM cf_agents_search_entries
+      WHERE label = ${this.label}
+    `[0]?.count ?? 0;
+		if (count === 0) return null;
+		return `${count} entries indexed. Recent:\n${this.agent.sql`
+      SELECT key FROM cf_agents_search_entries
+      WHERE label = ${this.label}
+      ORDER BY updated_at DESC
+      LIMIT 20
+    `.map((r) => `- ${r.key}`).join("\n")}`;
+	}
+	async search(query) {
+		this.ensureTable();
+		const sanitized = query.split(/\s+/).filter(Boolean).map((w) => `"${w.replace(/"/g, "\"\"")}"`).join(" ");
+		if (!sanitized) return null;
+		try {
+			const rows = this.agent.sql`
+        SELECT f.key, f.content
+        FROM cf_agents_search_fts f
+        WHERE cf_agents_search_fts MATCH ${sanitized}
+          AND f.label = ${this.label}
+        ORDER BY rank
+        LIMIT 10
+      `;
+			if (rows.length === 0) return null;
+			return rows.map((r) => `[${r.key}]\n${r.content}`).join("\n\n");
+		} catch {
+			return null;
+		}
+	}
+	async set(key, content) {
+		this.ensureTable();
+		this.deleteFTS(key);
+		this.agent.sql`
+      INSERT INTO cf_agents_search_entries (label, key, content)
+      VALUES (${this.label}, ${key}, ${content})
+      ON CONFLICT(label, key) DO UPDATE SET
+        content = ${content},
+        updated_at = CURRENT_TIMESTAMP
+    `;
+		this.agent.sql`
+      INSERT INTO cf_agents_search_fts (label, key, content)
+      VALUES (${this.label}, ${key}, ${content})
+    `;
+	}
+	deleteFTS(key) {
+		const rows = this.agent.sql`
+      SELECT rowid FROM cf_agents_search_fts
+      WHERE key = ${key} AND label = ${this.label}
+    `;
+		for (const row of rows) this.agent.sql`DELETE FROM cf_agents_search_fts WHERE rowid = ${row.rowid}`;
+	}
+};
+//#endregion
+//#region src/experimental/memory/session/skills.ts
+/**
+* Check if a provider is a SkillProvider (has a `load` method).
+*/
+function isSkillProvider(provider) {
+	return typeof provider === "object" && provider !== null && "load" in provider && typeof provider.load === "function";
+}
+/**
+* SkillProvider backed by an R2 bucket.
+*
+* - `get()` returns a metadata listing of all skills (key + description)
+* - `load(key)` fetches a skill's full content
+* - `set(key, content, description?)` writes a skill
+*
+* Descriptions are pulled from R2 custom metadata (`description` key).
+* If a prefix is provided, it is prepended on storage operations and
+* stripped from keys in metadata.
+*
+* @example
+* ```ts
+* const skills = new R2SkillProvider(env.SKILLS_BUCKET, { prefix: "skills/" });
+* ```
+*/
+var R2SkillProvider = class {
+	constructor(bucket, options) {
+		this.bucket = bucket;
+		this.prefix = options?.prefix ?? "";
+	}
+	async get() {
+		const entries = [];
+		let cursor;
+		let truncated = true;
+		while (truncated) {
+			const listed = await this.bucket.list({
+				prefix: this.prefix,
+				cursor,
+				include: ["customMetadata"]
+			});
+			for (const obj of listed.objects) {
+				const key = obj.key.slice(this.prefix.length);
+				const desc = obj.customMetadata?.description;
+				entries.push(`- ${key}${desc ? `: ${desc}` : ""}`);
+			}
+			truncated = listed.truncated;
+			cursor = listed.truncated ? listed.cursor : void 0;
+		}
+		return entries.length > 0 ? entries.join("\n") : null;
+	}
+	async load(key) {
+		const obj = await this.bucket.get(this.prefix + key);
+		if (!obj) return null;
+		return obj.text();
+	}
+	async set(key, content, description) {
+		await this.bucket.put(this.prefix + key, content, { customMetadata: description ? { description } : void 0 });
+	}
+};
+//#endregion
 //#region src/experimental/memory/session/context.ts
 /**
 * Context Block Management
@@ -11,8 +183,20 @@ import { jsonSchema } from "ai";
 * - 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) {
+	return typeof provider === "object" && provider !== null && "set" in provider && typeof provider.set === "function";
+}
+/**
 * Manages context blocks with frozen snapshot support.
 */
 var ContextBlocks = class {
@@ -32,16 +216,20 @@ var ContextBlocks = class {
 	*/
 	async load() {
 		for (const config of this.configs) {
-			let content = null;
-			if (config.provider) content = await config.provider.get();
-			content = content ?? config.initialContent ?? "";
+			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;
 			this.blocks.set(config.label, {
 				label: config.label,
 				description: config.description,
 				content,
 				tokens: estimateStringTokens(content),
 				maxTokens: config.maxTokens,
-				readonly: config.readonly
+				writable,
+				isSkill: skill,
+				isSearchable: searchable
 			});
 		}
 		this.loaded = true;
@@ -66,7 +254,8 @@ var ContextBlocks = class {
 		if (!this.loaded) await this.load();
 		const config = this.configs.find((c) => c.label === label);
 		const existing = this.blocks.get(label);
-		if (existing?.readonly || config?.readonly) throw new Error(`Block "${label}" is readonly`);
+		if (!existing?.writable) throw new Error(`Block "${label}" is readonly`);
+		if (existing.isSkill || existing.isSearchable) throw new Error(`Block "${label}" is a keyed provider. Use setSkill() or setSearchEntry() instead.`);
 		const tokens = estimateStringTokens(content);
 		const maxTokens = config?.maxTokens ?? existing?.maxTokens;
 		if (maxTokens !== void 0 && tokens > maxTokens) throw new Error(`Block "${label}" exceeds maxTokens: ${tokens} > ${maxTokens}`);
@@ -76,13 +265,64 @@ var ContextBlocks = class {
 			content,
 			tokens,
 			maxTokens,
-			readonly: false
+			writable: true,
+			isSkill: false,
+			isSearchable: false
 		};
 		this.blocks.set(label, block);
-		if (config?.provider?.set) await config.provider.set(content);
+		if (config?.provider && isWritableProvider(config.provider)) await config.provider.set(content);
 		return block;
 	}
 	/**
+	* Set a skill entry within a skill block.
+	*/
+	async setSkill(label, key, content, description) {
+		if (!this.loaded) await this.load();
+		const config = this.configs.find((c) => c.label === label);
+		const existing = this.blocks.get(label);
+		if (!existing?.isSkill) throw new Error(`Block "${label}" is not a skill provider`);
+		const provider = config?.provider;
+		if (!provider || !isSkillProvider(provider) || !provider.set) throw new Error(`Block "${label}" does not support writes`);
+		await provider.set(key, content, description);
+		const metadata = await provider.get();
+		if (metadata) {
+			existing.content = metadata;
+			existing.tokens = estimateStringTokens(metadata);
+		}
+	}
+	/**
+	* Load a skill's full content from a skill block.
+	*/
+	async loadSkill(label, key) {
+		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);
+	}
+	/**
+	* Index a search entry within a searchable block.
+	*/
+	async setSearchEntry(label, key, content) {
+		if (!this.loaded) await this.load();
+		const config = this.configs.find((c) => c.label === label);
+		const existing = this.blocks.get(label);
+		if (!existing?.isSearchable) throw new Error(`Block "${label}" is not a search provider`);
+		const provider = config?.provider;
+		if (!provider || !isSearchProvider(provider) || !provider.set) throw new Error(`Block "${label}" does not support writes`);
+		await provider.set(key, content);
+		existing.content = await provider.get() ?? "";
+		existing.tokens = estimateStringTokens(existing.content);
+	}
+	/**
+	* Search a searchable block.
+	*/
+	async searchContext(label, query) {
+		if (!this.loaded) await this.load();
+		const config = this.configs.find((c) => c.label === label);
+		if (!config?.provider || !isSearchProvider(config.provider)) throw new Error(`Block "${label}" is not a search provider`);
+		return config.provider.search(query);
+	}
+	/**
 	* Append content to a block.
 	*/
 	async appendToBlock(label, content) {
@@ -105,8 +345,6 @@ var ContextBlocks = class {
 	}
 	/**
 	* Force re-render the snapshot from current block state.
-	* Call this at the start of a new session to pick up changes
-	* made by setBlock() during the previous session.
 	*/
 	refreshSnapshot() {
 		return this.captureSnapshot();
@@ -115,14 +353,18 @@ var ContextBlocks = class {
 		const parts = [];
 		const sep = "═".repeat(46);
 		for (const block of this.blocks.values()) {
-			if (!block.content) continue;
+			if (!block.content && !block.isSearchable) continue;
 			let header = block.label.toUpperCase();
-			if (block.description) header += ` (${block.description})`;
+			const hints = [];
+			if (block.description) hints.push(block.description);
+			if (block.isSkill) hints.push("use load_context to load");
+			if (block.isSearchable) hints.push("use search_context to search");
+			if (hints.length > 0) header += ` (${hints.join(" — ")})`;
 			if (block.maxTokens) {
 				const pct = Math.round(block.tokens / block.maxTokens * 100);
 				header += ` [${pct}% — ${block.tokens}/${block.maxTokens} tokens]`;
 			}
-			if (block.readonly) header += " [readonly]";
+			if (!block.writable) header += " [readonly]";
 			parts.push(`${sep}\n${header}\n${sep}\n${block.content}`);
 		}
 		this.snapshot = parts.join("\n\n");
@@ -132,20 +374,36 @@ var ContextBlocks = class {
 	* Get writable blocks (for tool description).
 	*/
 	getWritableBlocks() {
-		return Array.from(this.blocks.values()).filter((b) => !b.readonly);
+		return Array.from(this.blocks.values()).filter((b) => b.writable);
 	}
 	/**
-	* Get writable block configs — doesn't require blocks to be loaded.
+	* Check if any skill providers are registered.
 	*/
-	getWritableConfigs() {
-		return this.configs.filter((c) => !c.readonly);
+	hasSkillBlocks() {
+		return Array.from(this.blocks.values()).some((b) => b.isSkill);
+	}
+	/**
+	* Get skill block labels.
+	*/
+	getSkillLabels() {
+		return Array.from(this.blocks.values()).filter((b) => b.isSkill).map((b) => b.label);
+	}
+	/**
+	* Check if any search providers are registered.
+	*/
+	hasSearchBlocks() {
+		return Array.from(this.blocks.values()).some((b) => b.isSearchable);
+	}
+	/**
+	* Get searchable block labels.
+	*/
+	getSearchLabels() {
+		return Array.from(this.blocks.values()).filter((b) => b.isSearchable).map((b) => b.label);
 	}
 	/**
 	* Frozen system prompt. On first call:
 	* 1. Checks store for a persisted prompt (survives DO eviction)
 	* 2. If none, loads blocks from providers, renders, and persists
-	*
-	* Subsequent calls return the stored version — true prefix cache stability.
 	*/
 	async freezeSystemPrompt() {
 		if (this.promptStore) {
@@ -154,59 +412,152 @@ var ContextBlocks = class {
 		}
 		if (!this.loaded) await this.load();
 		const prompt = this.toSystemPrompt();
-		if (this.promptStore?.set) await this.promptStore.set(prompt);
+		if (this.promptStore) await this.promptStore.set(prompt);
 		return prompt;
 	}
 	/**
 	* Re-render the system prompt from current block state and persist.
-	* Call after compaction or at session boundaries to pick up writes.
 	*/
 	async refreshSystemPrompt() {
 		if (!this.loaded) await this.load();
 		const prompt = this.refreshSnapshot();
-		if (this.promptStore?.set) await this.promptStore.set(prompt);
+		if (this.promptStore) await this.promptStore.set(prompt);
 		return prompt;
 	}
 	/**
-	* AI tool for updating context blocks. Loads blocks lazily on first execute.
+	* AI tools for context blocks.
+	*
+	* Auto-wired based on provider capabilities:
+	* - `set_context` — when any block is writable
+	* - `load_context` — when any block is a skill provider
+	* - `search_context` — when any block is a search provider
 	*/
 	async tools() {
 		if (!this.loaded) await this.load();
 		const writable = this.getWritableBlocks();
-		if (writable.length === 0) return {};
-		const blockDescriptions = writable.map((b) => `- "${b.label}": ${b.description ?? "no description"}`).join("\n");
-		const ctx = this;
-		return { update_context: {
-			description: `Update a context block. Available blocks:\n${blockDescriptions}\n\nWrites are durable and persist across sessions.`,
-			inputSchema: jsonSchema({
-				type: "object",
-				properties: {
-					label: {
-						type: "string",
-						enum: writable.map((b) => b.label),
-						description: "Block label to update"
+		const hasSkills = this.hasSkillBlocks();
+		const hasSearch = this.hasSearchBlocks();
+		const toolSet = {};
+		if (writable.length > 0) {
+			const regularBlocks = writable.filter((b) => !b.isSkill && !b.isSearchable);
+			const keyedBlocks = writable.filter((b) => b.isSkill || b.isSearchable);
+			const blockDescriptions = [];
+			for (const b of regularBlocks) blockDescriptions.push(`- "${b.label}": ${b.description ?? "no description"}`);
+			for (const b of keyedBlocks) {
+				const kind = b.isSkill ? "skill collection (requires key and optional description)" : "searchable (requires key)";
+				blockDescriptions.push(`- "${b.label}": ${kind}`);
+			}
+			const properties = {
+				label: {
+					type: "string",
+					enum: writable.map((b) => b.label),
+					description: "Block label to write to"
+				},
+				content: {
+					type: "string",
+					description: "Content to write"
+				},
+				action: {
+					type: "string",
+					enum: ["replace", "append"],
+					description: "replace (default) or append"
+				}
+			};
+			const required = ["label", "content"];
+			if (keyedBlocks.length > 0) properties.key = {
+				type: "string",
+				description: "Entry key (required for keyed blocks: " + keyedBlocks.map((b) => `"${b.label}"`).join(", ") + ")"
+			};
+			if (keyedBlocks.some((b) => b.isSkill)) properties.description = {
+				type: "string",
+				description: "Short description for the skill entry"
+			};
+			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({
+					type: "object",
+					properties,
+					required
+				}),
+				execute: async ({ label, content, key, description, action }) => {
+					try {
+						const block = this.blocks.get(label);
+						if (!block) return `Error: block "${label}" not found`;
+						if (block.isSkill) {
+							if (!key) return `Error: key is required for skill block "${label}"`;
+							await this.setSkill(label, key, content, description);
+							return `Written skill "${key}" to ${label}.`;
+						}
+						if (block.isSearchable) {
+							if (!key) return `Error: key is required for searchable block "${label}"`;
+							await this.setSearchEntry(label, key, content);
+							return `Indexed "${key}" in ${label}.`;
+						}
+						const updated = action === "append" ? await this.appendToBlock(label, content) : await this.setBlock(label, content);
+						return `Written to ${label}. Usage: ${updated.maxTokens ? `${Math.round(updated.tokens / updated.maxTokens * 100)}% (${updated.tokens}/${updated.maxTokens} tokens)` : `${updated.tokens} tokens`}`;
+					} catch (err) {
+						return `Error: ${err instanceof Error ? err.message : String(err)}`;
+					}
+				}
+			};
+		}
+		if (hasSkills) {
+			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({
+					type: "object",
+					properties: {
+						label: {
+							type: "string",
+							enum: skillLabels,
+							description: "Skill block label"
+						},
+						key: {
+							type: "string",
+							description: "Skill key to load"
+						}
 					},
-					content: {
-						type: "string",
-						description: "Content to write"
+					required: ["label", "key"]
+				}),
+				execute: async ({ label, key }) => {
+					try {
+						return await this.loadSkill(label, key) ?? `Not found: ${key}`;
+					} catch (err) {
+						return `Error: ${err instanceof Error ? err.message : String(err)}`;
+					}
+				}
+			};
+		}
+		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({
+					type: "object",
+					properties: {
+						label: {
+							type: "string",
+							enum: searchLabels,
+							description: "Searchable block label"
+						},
+						query: {
+							type: "string",
+							description: "Search query"
+						}
 					},
-					action: {
-						type: "string",
-						enum: ["replace", "append"],
-						description: "replace (default) or append"
+					required: ["label", "query"]
+				}),
+				execute: async ({ label, query }) => {
+					try {
+						return await this.searchContext(label, query) ?? "No results found.";
+					} catch (err) {
+						return `Error: ${err instanceof Error ? err.message : String(err)}`;
 					}
-				},
-				required: ["label", "content"]
-			}),
-			execute: async ({ label, content, action }) => {
-				try {
-					const block = action === "append" ? await ctx.appendToBlock(label, content) : await ctx.setBlock(label, content);
-					return `Written to ${label}. Usage: ${block.maxTokens ? `${Math.round(block.tokens / block.maxTokens * 100)}% (${block.tokens}/${block.maxTokens} tokens)` : `${block.tokens} tokens`}`;
-				} catch (err) {
-					return `Error: ${err instanceof Error ? err.message : String(err)}`;
 				}
-			}
-		} };
+			};
+		}
+		return toolSet;
 	}
 };
 //#endregion
@@ -483,7 +834,10 @@ var AgentContextProvider = class {
 	constructor(agent, label) {
 		this.initialized = false;
 		this.agent = agent;
-		this.label = label;
+		this.label = label ?? "";
+	}
+	init(label) {
+		if (!this.label) this.label = label;
 	}
 	ensureTable() {
 		if (this.initialized) return;
@@ -530,17 +884,14 @@ var Session = class Session {
 	* @example
 	* ```ts
 	* const session = Session.create(this)
-	*   .withContext("soul", { initialContent: "You are helpful.", readonly: true })
+	*   .withContext("soul", { provider: { get: async () => "You are helpful." } })
 	*   .withContext("memory", { description: "Learned facts", maxTokens: 1100 })
 	*   .withCachedPrompt();
 	*
-	* // Custom storage (R2, KV, etc.)
+	* // Skills from R2 (on-demand loading via load_context tool)
 	* const session = Session.create(this)
-	*   .withContext("workspace", {
-	*     provider: {
-	*       get: () => env.BUCKET.get("ws.md").then(o => o?.text() ?? null),
-	*       set: (c) => env.BUCKET.put("ws.md", c),
-	*     }
+	*   .withContext("skills", {
+	*     provider: new R2SkillProvider(env.SKILLS_BUCKET, { prefix: "skills/" })
 	*   })
 	*   .withCachedPrompt();
 	* ```
@@ -588,16 +939,14 @@ var Session = class Session {
 		if (this._ready) return;
 		const configs = (this._pending ?? []).map(({ label, options: opts }) => {
 			let provider = opts.provider;
-			if (!provider && !opts.readonly) {
+			if (!provider) {
 				const key = this._sessionId ? `${label}_${this._sessionId}` : label;
 				provider = new AgentContextProvider(this._agent, key);
 			}
 			return {
 				label,
 				description: opts.description,
-				initialContent: opts.initialContent,
 				maxTokens: opts.maxTokens,
-				readonly: opts.readonly,
 				provider
 			};
 		});
@@ -743,13 +1092,352 @@ var Session = class Session {
 		if (!this.storage.searchMessages) throw new Error("Session provider does not support search");
 		return this.storage.searchMessages(query, options?.limit ?? 20);
 	}
-	/** Returns update_context tool for writing to context blocks. */
+	/** Returns set_context and load_context tools. */
 	async tools() {
 		this._ensureReady();
 		return this.context.tools();
 	}
 };
 //#endregion
-export { AgentContextProvider, AgentSessionProvider, Session };
+//#region src/experimental/memory/session/manager.ts
+var SessionManager = class SessionManager {
+	constructor(agent, options = {}) {
+		this._maxContextMessages = 100;
+		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();
+	}
+	/**
+	* Chainable SessionManager creation with auto-wired context for all sessions.
+	*
+	* @example
+	* ```ts
+	* const manager = SessionManager.create(this)
+	*   .withContext("soul", { provider: { get: async () => "You are helpful." } })
+	*   .withContext("memory", { description: "Learned facts", maxTokens: 1100 })
+	*   .withCachedPrompt()
+	*   .maxContextMessages(50);
+	*
+	* // Each getSession(id) auto-creates namespaced providers:
+	* //   memory key: "memory_<sessionId>"
+	* //   prompt key: "_system_prompt_<sessionId>"
+	* const session = manager.getSession("chat-123");
+	* ```
+	*/
+	static create(agent) {
+		const mgr = Object.create(SessionManager.prototype);
+		mgr.agent = agent;
+		mgr._maxContextMessages = 100;
+		mgr._pending = [];
+		mgr._compactionFn = null;
+		mgr._tokenThreshold = void 0;
+		mgr._sessions = /* @__PURE__ */ new Map();
+		mgr._tableReady = false;
+		mgr._ready = false;
+		return mgr;
+	}
+	withContext(label, options) {
+		this._pending.push({
+			label,
+			options: options ?? {}
+		});
+		return this;
+	}
+	withCachedPrompt(provider) {
+		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.
+	*/
+	onCompaction(fn) {
+		this._compactionFn = fn;
+		return this;
+	}
+	/**
+	* Auto-compact when estimated token count exceeds the threshold.
+	* Propagated to all sessions. Requires `onCompaction()`.
+	*/
+	compactAfter(tokenThreshold) {
+		this._tokenThreshold = tokenThreshold;
+		return this;
+	}
+	/**
+	* Add a searchable context block that searches conversation history
+	* across all sessions managed by this manager.
+	*
+	* The model can use `search_context` to find relevant messages from
+	* any session. The block is readonly (no `set`).
+	*
+	* @example
+	* ```ts
+	* SessionManager.create(this)
+	*   .withContext("memory", { maxTokens: 1100 })
+	*   .withSearchableHistory("history")
+	*   .withCachedPrompt();
+	* ```
+	*/
+	withSearchableHistory(label) {
+		this._historyLabel = label;
+		return this;
+	}
+	_ensureReady() {
+		if (this._ready) return;
+		this._ready = true;
+		this._ensureTable();
+	}
+	_ensureTable() {
+		if (this._tableReady) return;
+		this.agent.sql`
+      CREATE TABLE IF NOT EXISTS assistant_sessions (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        parent_session_id TEXT,
+        model TEXT,
+        source TEXT,
+        input_tokens INTEGER DEFAULT 0,
+        output_tokens INTEGER DEFAULT 0,
+        estimated_cost REAL DEFAULT 0,
+        end_reason TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+		this.agent.sql`
+      CREATE VIRTUAL TABLE IF NOT EXISTS assistant_fts
+      USING fts5(id UNINDEXED, session_id UNINDEXED, role UNINDEXED, content, tokenize='porter unicode61')
+    `;
+		this._tableReady = true;
+	}
+	_createHistoryProvider() {
+		const mgr = this;
+		return {
+			async get() {
+				const sessions = mgr.list();
+				if (sessions.length === 0) return null;
+				return `${sessions.length} session${sessions.length === 1 ? "" : "s"} available for search.`;
+			},
+			async search(query) {
+				const results = mgr.search(query, { limit: 10 });
+				if (results.length === 0) return null;
+				return results.map((r) => `[${r.role}] ${r.content}`).join("\n---\n");
+			}
+		};
+	}
+	/** Get or create the Session instance for a session ID. */
+	getSession(sessionId) {
+		this._ensureReady();
+		let session = this._sessions.get(sessionId);
+		if (!session) {
+			const s = Session.create(this.agent).forSession(sessionId);
+			for (const { label, options } of this._pending) s.withContext(label, options);
+			if (this._cachedPrompt === true) s.withCachedPrompt();
+			else if (this._cachedPrompt) s.withCachedPrompt(this._cachedPrompt);
+			if (this._historyLabel) s.withContext(this._historyLabel, {
+				description: "Cross-session conversation history",
+				provider: this._createHistoryProvider()
+			});
+			if (this._compactionFn) s.onCompaction(this._compactionFn);
+			if (this._tokenThreshold != null) s.compactAfter(this._tokenThreshold);
+			session = s;
+			this._sessions.set(sessionId, session);
+		}
+		return session;
+	}
+	create(name, opts) {
+		this._ensureReady();
+		const id = crypto.randomUUID();
+		this.agent.sql`
+      INSERT INTO assistant_sessions (id, name, parent_session_id, model, source)
+      VALUES (${id}, ${name}, ${opts?.parentSessionId ?? null}, ${opts?.model ?? null}, ${opts?.source ?? null})
+    `;
+		return this.get(id);
+	}
+	get(sessionId) {
+		this._ensureReady();
+		return this.agent.sql`
+      SELECT * FROM assistant_sessions WHERE id = ${sessionId}
+    `[0] ?? null;
+	}
+	list() {
+		this._ensureReady();
+		return this.agent.sql`
+      SELECT * FROM assistant_sessions ORDER BY updated_at DESC
+    `;
+	}
+	delete(sessionId) {
+		this.getSession(sessionId).clearMessages();
+		this.agent.sql`DELETE FROM assistant_sessions WHERE id = ${sessionId}`;
+		this._sessions.delete(sessionId);
+	}
+	rename(sessionId, name) {
+		this._ensureReady();
+		this.agent.sql`
+      UPDATE assistant_sessions SET name = ${name}, updated_at = CURRENT_TIMESTAMP
+      WHERE id = ${sessionId}
+    `;
+	}
+	async append(sessionId, message, parentId) {
+		await this.getSession(sessionId).appendMessage(message, parentId);
+		this._touch(sessionId);
+		return message.id;
+	}
+	async upsert(sessionId, message, parentId) {
+		const session = this.getSession(sessionId);
+		if (session.getMessage(message.id)) session.updateMessage(message);
+		else await session.appendMessage(message, parentId);
+		this._touch(sessionId);
+		return message.id;
+	}
+	async appendAll(sessionId, messages, parentId) {
+		const session = this.getSession(sessionId);
+		let lastParent = parentId ?? null;
+		for (const msg of messages) {
+			await session.appendMessage(msg, lastParent);
+			lastParent = msg.id;
+		}
+		this._touch(sessionId);
+		return lastParent;
+	}
+	getHistory(sessionId, leafId) {
+		return this.getSession(sessionId).getHistory(leafId);
+	}
+	getMessageCount(sessionId) {
+		return this.getSession(sessionId).getPathLength();
+	}
+	clearMessages(sessionId) {
+		this.getSession(sessionId).clearMessages();
+		this._touch(sessionId);
+	}
+	deleteMessages(sessionId, messageIds) {
+		this.getSession(sessionId).deleteMessages(messageIds);
+		this._touch(sessionId);
+	}
+	getBranches(sessionId, messageId) {
+		return this.getSession(sessionId).getBranches(messageId);
+	}
+	/**
+	* Fork a session at a specific message, creating a new session
+	* with the history up to that point copied over.
+	*/
+	async fork(sessionId, atMessageId, newName) {
+		const info = this.create(newName, { parentSessionId: sessionId });
+		const history = this.getSession(sessionId).getHistory(atMessageId);
+		const newSession = this.getSession(info.id);
+		let parentId = null;
+		for (const msg of history) {
+			const newId = crypto.randomUUID();
+			const copy = {
+				...msg,
+				id: newId
+			};
+			await newSession.appendMessage(copy, parentId);
+			parentId = newId;
+		}
+		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);
+	}
+	getCompactions(sessionId) {
+		return this.getSession(sessionId).getCompactions();
+	}
+	async compactAndSplit(sessionId, summary, newName) {
+		const old = this.get(sessionId);
+		this.agent.sql`
+      UPDATE assistant_sessions SET end_reason = 'compaction', updated_at = CURRENT_TIMESTAMP
+      WHERE id = ${sessionId}
+    `;
+		const info = this.create(newName ?? old?.name ?? "Compacted", {
+			parentSessionId: sessionId,
+			model: old?.model ?? void 0,
+			source: old?.source ?? void 0
+		});
+		await this.append(info.id, {
+			id: crypto.randomUUID(),
+			role: "assistant",
+			parts: [{
+				type: "text",
+				text: `[Context from previous session]\n\n${summary}`
+			}]
+		});
+		return info;
+	}
+	addUsage(sessionId, inputTokens, outputTokens, cost) {
+		this._ensureReady();
+		this.agent.sql`
+      UPDATE assistant_sessions SET
+        input_tokens = input_tokens + ${inputTokens},
+        output_tokens = output_tokens + ${outputTokens},
+        estimated_cost = estimated_cost + ${cost},
+        updated_at = CURRENT_TIMESTAMP
+      WHERE id = ${sessionId}
+    `;
+	}
+	search(query, options) {
+		this._ensureReady();
+		const limit = options?.limit ?? 20;
+		const sanitized = query.split(/\s+/).filter(Boolean).map((w) => `"${w.replace(/"/g, "\"\"")}"`).join(" ");
+		if (!sanitized) return [];
+		try {
+			return this.agent.sql`
+        SELECT id, role, content FROM assistant_fts
+        WHERE assistant_fts MATCH ${sanitized}
+        ORDER BY rank LIMIT ${limit}
+      `.map((r) => ({
+				id: r.id,
+				role: r.role,
+				content: r.content,
+				createdAt: ""
+			}));
+		} catch {
+			return [];
+		}
+	}
+	tools() {
+		return { session_search: {
+			description: "Search past conversations for relevant context. Searches across all sessions.",
+			inputSchema: jsonSchema({
+				type: "object",
+				properties: { query: {
+					type: "string",
+					description: "Search query"
+				} },
+				required: ["query"]
+			}),
+			execute: async ({ query }) => {
+				try {
+					const results = this.search(query, { limit: 10 });
+					if (results.length === 0) return "No results found.";
+					return results.map((r) => `[${r.role}] ${r.content}`).join("\n---\n");
+				} catch (err) {
+					return `Error: ${err instanceof Error ? err.message : String(err)}`;
+				}
+			}
+		} };
+	}
+	_touch(sessionId) {
+		this.agent.sql`
+      UPDATE assistant_sessions SET updated_at = CURRENT_TIMESTAMP
+      WHERE id = ${sessionId}
+    `;
+	}
+};
+//#endregion
+export { AgentContextProvider, AgentSearchProvider, AgentSessionProvider, R2SkillProvider, Session, SessionManager, isSearchProvider, isSkillProvider, isWritableProvider };
 
 //# sourceMappingURL=index.js.map