agents 0.21.0 → 0.23.0

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

@@ -1,2374 +0,0 @@
-import "../../../types.js";
-import { m as estimateStringTokens, p as estimateMessageTokens, t as COMPACTION_PREFIX } from "../../../compaction-helpers-iiKMr2TQ.js";
-import { z } from "zod";
-//#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.`;
-	}
-	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. `keys`, when provided, is matched against
-* these prefix-relative keys.
-*
-* @example
-* ```ts
-* const skills = new R2SkillProvider(env.SKILLS_BUCKET, {
-*   prefix: "skills/",
-*   keys: ["code-review", "debugging"]
-* });
-* ```
-*/
-var R2SkillProvider = class {
-	constructor(bucket, options) {
-		this.bucket = bucket;
-		this.prefix = options?.prefix ?? "";
-		this.keys = options?.keys?.length ? new Set(options.keys) : null;
-	}
-	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);
-				if (!this.allowsKey(key)) continue;
-				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) {
-		if (!this.allowsKey(key)) return null;
-		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 });
-	}
-	allowsKey(key) {
-		return this.keys === null || this.keys.has(key);
-	}
-};
-//#endregion
-//#region src/experimental/memory/session/context.ts
-function slugify(text) {
-	return text.slice(0, 60).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-function stableHash(text) {
-	let hash = 2166136261;
-	for (let i = 0; i < text.length; i++) {
-		hash ^= text.charCodeAt(i);
-		hash = Math.imul(hash, 16777619);
-	}
-	return (hash >>> 0).toString(36);
-}
-function contextEntryKey(metadataTitle, content) {
-	if (metadataTitle?.trim()) return slugify(metadataTitle) || `entry-${stableHash(metadataTitle)}`;
-	return `${slugify(content) || "entry"}-${stableHash(content)}`;
-}
-/**
-* 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 {
-	constructor(configs, promptStore) {
-		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;
-	}
-	/**
-	* Load all blocks from their providers.
-	* Called once at session init.
-	*/
-	async load() {
-		for (const config of this.configs) {
-			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,
-				writable,
-				isSkill: skill,
-				isSearchable: searchable
-			});
-		}
-		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) {
-		return this.blocks.get(label) ?? null;
-	}
-	/**
-	* Get all blocks.
-	*/
-	getBlocks() {
-		return Array.from(this.blocks.values());
-	}
-	/**
-	* Set block content. Writes to provider immediately.
-	* Does NOT update the frozen snapshot.
-	*/
-	async setBlock(label, content) {
-		if (!this.loaded) await this.load();
-		const config = this.configs.find((c) => c.label === label);
-		const existing = this.blocks.get(label);
-		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}`);
-		const block = {
-			label,
-			description: config?.description ?? existing?.description,
-			content,
-			tokens,
-			maxTokens,
-			writable: true,
-			isSkill: false,
-			isSearchable: false
-		};
-		this.blocks.set(label, block);
-		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`);
-		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.
-	*/
-	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) {
-		if (!this.loaded) await this.load();
-		const existing = this.blocks.get(label);
-		if (!existing) throw new Error(`Block "${label}" not found`);
-		const needsSep = existing.content.length > 0 && !content.startsWith("\n");
-		return this.setBlock(label, existing.content + (needsSep ? "\n" : "") + content);
-	}
-	/**
-	* Get the system prompt string with context blocks.
-	*
-	* Returns a frozen snapshot: first call renders and caches,
-	* subsequent calls return the same string (preserves LLM prefix cache).
-	* Call refreshSnapshot() to re-render after block changes take effect.
-	*/
-	toSystemPrompt() {
-		if (!this.loaded) throw new Error("Context blocks not loaded. Call load() first.");
-		if (this.snapshot !== null) return this.snapshot;
-		return this.captureSnapshot();
-	}
-	/**
-	* Force re-render the snapshot from current block state.
-	*/
-	refreshSnapshot() {
-		return this.captureSnapshot();
-	}
-	renderPrompt() {
-		const parts = [];
-		const sep = "═".repeat(46);
-		for (const block of this.blocks.values()) {
-			if (!block.content && !block.writable && !block.isSearchable && !block.isSkill) continue;
-			let header = block.label.toUpperCase();
-			if (block.description) header += ` (${block.description})`;
-			if (block.maxTokens) {
-				const pct = Math.round(block.tokens / block.maxTokens * 100);
-				header += ` [${pct}% — ${block.tokens}/${block.maxTokens} tokens]`;
-			}
-			if (block.isSearchable) header += " [searchable]";
-			else if (block.isSkill) header += " [loadable]";
-			else if (!block.writable) header += " [readonly]";
-			else header += " [writable]";
-			parts.push(`${sep}\n${header}\n${sep}\n${block.content}`);
-		}
-		return parts.join("\n\n");
-	}
-	captureSnapshot() {
-		this.snapshot = this.renderPrompt();
-		return this.snapshot;
-	}
-	/**
-	* Get writable blocks (for tool description).
-	*/
-	getWritableBlocks() {
-		return Array.from(this.blocks.values()).filter((b) => b.writable);
-	}
-	/**
-	* Check if any skill providers are registered.
-	*/
-	hasSkillBlocks() {
-		return Array.from(this.blocks.values()).some((b) => b.isSkill);
-	}
-	/**
-	* Check whether any CONFIGURED provider is skill-capable, without
-	* requiring `load()` to have run. Used by Session to decide whether the
-	* init-time loaded-skill restore scan is needed at all.
-	*/
-	hasSkillCapableConfigs() {
-		return this.configs.some((c) => c.provider !== void 0 && isSkillProvider(c.provider));
-	}
-	/**
-	* 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);
-	}
-	/**
-	* Return the cached system prompt. If no cached prompt exists,
-	* loads blocks from providers, renders, and persists to the store.
-	* Subsequent calls return the stored value without re-rendering.
-	*/
-	async freezeSystemPrompt() {
-		if (this.promptStore) {
-			const stored = await this.promptStore.get();
-			if (stored !== null) return stored;
-		}
-		if (!this.loaded) await this.load();
-		const prompt = this.toSystemPrompt();
-		if (this.promptStore) await this.promptStore.set(prompt);
-		return prompt;
-	}
-	/**
-	* Return the prompt text used for token estimation without persisting a new
-	* frozen prompt to the prompt store.
-	*
-	* This still reads an existing cached prompt when present, so estimates match
-	* the prompt that inference would reuse. If no cached prompt exists, it loads
-	* providers and renders the current blocks without freezing the snapshot.
-	*/
-	async getSystemPromptForEstimate() {
-		if (this.snapshot !== null) return this.snapshot;
-		if (this.promptStore) {
-			const stored = await this.promptStore.get();
-			if (stored !== null) return stored;
-		}
-		if (!this.loaded) await this.load();
-		return this.renderPrompt();
-	}
-	/**
-	* Force reload blocks from providers, re-render the system prompt,
-	* and persist to the store. Use this after block content has changed
-	* or to invalidate the cached prompt.
-	*/
-	async refreshSystemPrompt() {
-		this.loaded = false;
-		await this.load();
-		const prompt = this.refreshSnapshot();
-		if (this.promptStore) await this.promptStore.set(prompt);
-		return prompt;
-	}
-	/**
-	* 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();
-		const hasSkills = this.hasSkillBlocks();
-		const hasSearch = this.hasSearchBlocks();
-		const toolSet = {};
-		if (writable.length > 0) {
-			const blockDescriptions = writable.map((b) => {
-				const kind = b.isSkill ? "skill collection, keyed entries" : b.isSearchable ? "searchable, keyed entries" : "writable";
-				return `- "${b.label}" (${kind}): ${b.description ?? "no description"}`;
-			});
-			const keyedBlocks = writable.filter((b) => b.isSkill || b.isSearchable);
-			const properties = {
-				label: {
-					type: "string",
-					enum: writable.map((b) => b.label),
-					description: "Block label to write to"
-				},
-				content: {
-					type: "string",
-					description: "The main content to write to the block."
-				},
-				action: {
-					type: "string",
-					enum: ["replace", "append"],
-					description: "replace (default) or append"
-				}
-			};
-			if (keyedBlocks.length > 0) properties.metadata = {
-				type: "object",
-				description: "Optional metadata for keyed entries (skill collections, searchable blocks: " + keyedBlocks.map((b) => `"${b.label}"`).join(", ") + "). Short content doesn't need metadata; longer loadable entries (skills) benefit from a title and description so the model can pick the right one without loading it.",
-				properties: {
-					title: {
-						type: "string",
-						description: "Short title. Used as a stable identifier — entries with the same title are updated in place, different titles create new entries."
-					},
-					description: {
-						type: "string",
-						description: "One-line summary shown alongside the title in the system prompt so the model can decide when to load the entry."
-					}
-				}
-			};
-			const metadataHint = keyedBlocks.length > 0 ? "\n\nFor keyed blocks (skill collections / searchable), pass `metadata: { title, description }` — title stabilises updates, description helps the model pick entries. Metadata is optional; short content rarely needs it, long loadable entries benefit most." : "";
-			toolSet.set_context = {
-				description: `Write to a context block. Available blocks:\n${blockDescriptions.join("\n")}\n\nWrites are durable and persist across sessions.${metadataHint}`,
-				inputSchema: z.fromJSONSchema({
-					type: "object",
-					properties,
-					required: ["label", "content"]
-				}),
-				execute: async ({ label, content, metadata, action }) => {
-					try {
-						const block = this.blocks.get(label);
-						if (!block) return `Error: block "${label}" not found`;
-						if (block.isSkill || block.isSearchable) {
-							const title = metadata?.title;
-							const description = metadata?.description;
-							const key = contextEntryKey(title, content);
-							if (block.isSkill) await this.setSkill(label, key, content, description ?? title);
-							else 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: z.fromJSONSchema({
-					type: "object",
-					properties: {
-						label: {
-							type: "string",
-							enum: skillLabels,
-							description: "Skill block label"
-						},
-						key: {
-							type: "string",
-							description: "Skill key to load"
-						}
-					},
-					required: ["label", "key"]
-				}),
-				execute: async ({ label, key }) => {
-					try {
-						if (!skillLabels.includes(label)) return `Error: "${label}" is not a skill block. Skill blocks: ${skillLabels.join(", ")}`;
-						return await this.loadSkill(label, key) ?? `Not found: ${key}`;
-					} catch (err) {
-						return `Error: ${err instanceof Error ? err.message : String(err)}`;
-					}
-				}
-			};
-			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 (!skillLabels.includes(label)) return `Error: "${label}" is not a skill block. Skill blocks: ${skillLabels.join(", ")}`;
-					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. ONLY these blocks are searchable: " + searchLabels.map((l) => `"${l}"`).join(", ") + ". Other blocks cannot be searched.",
-				inputSchema: z.fromJSONSchema({
-					type: "object",
-					properties: {
-						label: {
-							type: "string",
-							enum: searchLabels,
-							description: "Searchable block label"
-						},
-						query: {
-							type: "string",
-							description: "Search query"
-						}
-					},
-					required: ["label", "query"]
-				}),
-				execute: async ({ label, query }) => {
-					try {
-						if (!searchLabels.includes(label)) return `Error: "${label}" is not searchable. Searchable blocks: ${searchLabels.join(", ")}`;
-						return await this.searchContext(label, query) ?? "No results found.";
-					} catch (err) {
-						return `Error: ${err instanceof Error ? err.message : String(err)}`;
-					}
-				}
-			};
-		}
-		return toolSet;
-	}
-};
-//#endregion
-//#region src/experimental/memory/session/providers/agent.ts
-/**
-* Bounds for each content-hydration query on a history path.
-*
-* Message rows can be up to ~1.8MB each (see ROW_MAX_BYTES in agents/chat),
-* so content is fetched in bounded batches rather than one statement to keep
-* any per-statement buffering in the SQLite layer small. In workerd the
-* SQLite allocator shares the isolate's memory budget with the JS heap —
-* oversized transient result sets surface as SQLITE_NOMEM (#1710).
-*
-* Chunks are bounded by BOTH row count and cumulative stored bytes (sizes
-* come from the path row stats, so no content is read to compute them).
-* Without the byte bound, 50 near-cap rows could still materialize ~90MB
-* in a single statement.
-*/
-const HISTORY_CONTENT_CHUNK_SIZE = 50;
-const HISTORY_CONTENT_CHUNK_BYTES = 4 * 1024 * 1024;
-var AgentSessionProvider = class {
-	/**
-	* @param agent - Agent or any object with a `sql` tagged template method
-	* @param sessionId - Optional session ID to isolate multiple sessions in the same DO.
-	*                    Messages are filtered by session_id within shared tables.
-	*/
-	constructor(agent, sessionId) {
-		this.initialized = false;
-		this.activeLeafId = void 0;
-		this.agent = agent;
-		this.sessionId = sessionId ?? "";
-	}
-	ensureTable() {
-		if (this.initialized) return;
-		this.agent.sql`
-      CREATE TABLE IF NOT EXISTS assistant_messages (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL DEFAULT '',
-        parent_id TEXT,
-        role TEXT NOT NULL,
-        content TEXT NOT NULL,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-		this.agent.sql`
-      CREATE INDEX IF NOT EXISTS idx_assistant_msg_parent
-      ON assistant_messages(parent_id)
-    `;
-		this.agent.sql`
-      CREATE INDEX IF NOT EXISTS idx_assistant_msg_session
-      ON assistant_messages(session_id)
-    `;
-		this.agent.sql`
-      CREATE TABLE IF NOT EXISTS assistant_compactions (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL DEFAULT '',
-        summary TEXT NOT NULL,
-        from_message_id TEXT NOT NULL,
-        to_message_id TEXT NOT NULL,
-        created_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.agent.sql`
-      CREATE TABLE IF NOT EXISTS assistant_config (
-        session_id TEXT NOT NULL,
-        key TEXT NOT NULL,
-        value TEXT NOT NULL,
-        PRIMARY KEY (session_id, key)
-      )
-    `;
-		this.initialized = true;
-	}
-	getMessage(id) {
-		this.ensureTable();
-		const rows = this.agent.sql`
-      SELECT content FROM assistant_messages WHERE id = ${id} AND session_id = ${this.sessionId}
-    `;
-		return rows.length > 0 ? this.parse(rows[0].content) : null;
-	}
-	getHistory(leafId) {
-		this.ensureTable();
-		const leaf = leafId ? this.leafRowById(leafId) : this.latestLeafRow();
-		if (!leaf) return [];
-		const messages = this.messagesByPathStats(this.pathRowStats(leaf.id));
-		const compactions = this.getCompactions();
-		if (compactions.length === 0) return messages;
-		return this.applyCompactions(messages, compactions);
-	}
-	getRecentHistory(leafId, maxContentBytes, minRecentMessages = 1) {
-		this.ensureTable();
-		const leaf = leafId ? this.leafRowById(leafId) : this.latestLeafRow();
-		if (!leaf) return {
-			messages: [],
-			truncated: false,
-			totalContentBytes: 0
-		};
-		const stats = this.pathRowStats(leaf.id);
-		const totalContentBytes = stats.reduce((sum, row) => sum + row.bytes, 0);
-		const minRecent = Math.max(1, Math.floor(minRecentMessages));
-		let start = stats.length - 1;
-		let used = stats[start]?.bytes ?? 0;
-		while (start > 0 && (stats.length - start < minRecent || used + stats[start - 1].bytes <= maxContentBytes)) {
-			start--;
-			used += stats[start].bytes;
-		}
-		const messages = this.messagesByPathStats(stats.slice(start));
-		const compactions = this.getCompactions();
-		return {
-			messages: compactions.length === 0 ? messages : this.applyCompactions(messages, compactions),
-			truncated: start > 0,
-			totalContentBytes
-		};
-	}
-	getHistoryRowStats(leafId) {
-		this.ensureTable();
-		const leaf = leafId ? this.leafRowById(leafId) : this.latestLeafRow();
-		return leaf ? this.pathRowStats(leaf.id) : [];
-	}
-	getLatestLeaf() {
-		this.ensureTable();
-		const row = this.latestLeafRow();
-		return row ? this.getMessage(row.id) : null;
-	}
-	getBranches(messageId) {
-		this.ensureTable();
-		const rows = this.agent.sql`
-      SELECT content FROM assistant_messages
-      WHERE parent_id = ${messageId} AND session_id = ${this.sessionId} ORDER BY created_at ASC
-    `;
-		return this.parseRows(rows);
-	}
-	getPathLength(leafId) {
-		this.ensureTable();
-		const leaf = leafId ? this.agent.sql`
-          SELECT id FROM assistant_messages WHERE id = ${leafId} AND session_id = ${this.sessionId}
-        `[0] : this.latestLeafRow();
-		if (!leaf) return 0;
-		return this.agent.sql`
-      WITH RECURSIVE path AS (
-        SELECT id, parent_id, 0 as depth FROM assistant_messages WHERE id = ${leaf.id}
-        UNION ALL
-        SELECT m.id, m.parent_id, p.depth + 1 FROM assistant_messages m
-        JOIN path p ON m.id = p.parent_id
-        WHERE m.session_id = ${this.sessionId} AND p.depth < 10000
-      )
-      SELECT COUNT(*) as count FROM path
-    `[0]?.count ?? 0;
-	}
-	appendMessage(message, parentId) {
-		this.ensureTable();
-		if (this.agent.sql`
-      SELECT id FROM assistant_messages WHERE id = ${message.id} AND session_id = ${this.sessionId}
-    `.length > 0) return;
-		let parent = parentId !== void 0 ? parentId : this.latestLeafRow()?.id ?? null;
-		if (parent) {
-			if (this.agent.sql`
-        SELECT id FROM assistant_messages WHERE id = ${parent} AND session_id = ${this.sessionId}
-      `.length === 0) parent = null;
-		}
-		const json = JSON.stringify(message);
-		this.agent.sql`
-      INSERT INTO assistant_messages (id, session_id, parent_id, role, content)
-      VALUES (${message.id}, ${this.sessionId}, ${parent}, ${message.role}, ${json})
-    `;
-		this.indexFTS(message);
-		this.activeLeafId = message.id;
-	}
-	updateMessage(message) {
-		this.ensureTable();
-		this.agent.sql`
-      UPDATE assistant_messages SET content = ${JSON.stringify(message)}
-      WHERE id = ${message.id} AND session_id = ${this.sessionId}
-    `;
-		this.indexFTS(message);
-	}
-	deleteMessages(messageIds) {
-		this.ensureTable();
-		for (const id of messageIds) {
-			this.agent.sql`DELETE FROM assistant_messages WHERE id = ${id} AND session_id = ${this.sessionId}`;
-			this.deleteFTS(id);
-		}
-		if (typeof this.activeLeafId === "string" && messageIds.includes(this.activeLeafId)) this.activeLeafId = void 0;
-	}
-	clearMessages() {
-		this.ensureTable();
-		this.agent.sql`DELETE FROM assistant_messages WHERE session_id = ${this.sessionId}`;
-		this.agent.sql`DELETE FROM assistant_compactions WHERE session_id = ${this.sessionId}`;
-		const ftsRows = this.agent.sql`
-      SELECT rowid FROM assistant_fts WHERE session_id = ${this.sessionId}
-    `;
-		for (const row of ftsRows) this.agent.sql`DELETE FROM assistant_fts WHERE rowid = ${row.rowid}`;
-		this.activeLeafId = void 0;
-	}
-	addCompaction(summary, fromMessageId, toMessageId) {
-		this.ensureTable();
-		const id = crypto.randomUUID();
-		this.agent.sql`
-      INSERT INTO assistant_compactions (id, session_id, summary, from_message_id, to_message_id)
-      VALUES (${id}, ${this.sessionId}, ${summary}, ${fromMessageId}, ${toMessageId})
-    `;
-		return {
-			id,
-			summary,
-			fromMessageId,
-			toMessageId,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-	}
-	getCompactions() {
-		this.ensureTable();
-		return this.agent.sql`
-      SELECT * FROM assistant_compactions WHERE session_id = ${this.sessionId} ORDER BY created_at ASC
-    `.map((r) => ({
-			id: r.id,
-			summary: r.summary,
-			fromMessageId: r.from_message_id,
-			toMessageId: r.to_message_id,
-			createdAt: r.created_at
-		}));
-	}
-	searchMessages(query, limit = 20) {
-		this.ensureTable();
-		const sanitized = `"${query.replace(/"/g, "\"\"")}"`;
-		try {
-			return this.agent.sql`
-        SELECT f.id, f.role, f.content FROM assistant_fts f
-        INNER JOIN assistant_messages m ON m.id = f.id AND m.session_id = f.session_id
-        WHERE assistant_fts MATCH ${sanitized} AND f.session_id = ${this.sessionId}
-        ORDER BY rank LIMIT ${limit}
-      `.map((r) => ({
-				id: r.id,
-				role: r.role,
-				content: r.content
-			}));
-		} catch {
-			return [];
-		}
-	}
-	latestLeafRow() {
-		if (this.activeLeafId !== void 0) {
-			if (this.agent.sql`
-        SELECT m.id FROM assistant_messages m
-        WHERE m.id = ${this.activeLeafId} AND m.session_id = ${this.sessionId}
-          AND NOT EXISTS (
-            SELECT 1 FROM assistant_messages c
-            WHERE c.parent_id = ${this.activeLeafId}
-              AND c.session_id = ${this.sessionId}
-          )
-      `.length > 0) return { id: this.activeLeafId };
-			this.activeLeafId = void 0;
-		}
-		const rows = this.agent.sql`
-      SELECT m.id FROM assistant_messages m
-      LEFT JOIN assistant_messages c ON c.parent_id = m.id AND c.session_id = ${this.sessionId}
-      WHERE c.id IS NULL AND m.session_id = ${this.sessionId}
-      ORDER BY m.created_at DESC, m.rowid DESC LIMIT 1
-    `;
-		this.activeLeafId = rows[0]?.id;
-		return rows[0] ?? null;
-	}
-	leafRowById(leafId) {
-		return this.agent.sql`
-      SELECT id FROM assistant_messages WHERE id = ${leafId} AND session_id = ${this.sessionId}
-    `[0] ?? null;
-	}
-	/**
-	* The active branch path as (id, role, content size) rows, root → leaf.
-	*
-	* Recurses over (id, parent_id) only. Carrying `content` through the
-	* recursive queue AND the ORDER BY sorter materializes the entire
-	* transcript several times over inside SQLite's allocator, which in
-	* workerd shares the isolate's memory budget with the JS heap — large
-	* media-heavy sessions then fail with SQLITE_NOMEM on wake (#1710).
-	* Content is fetched separately in bounded chunks (`messagesByPathStats`).
-	*/
-	pathRowStats(leafId) {
-		return this.agent.sql`
-      WITH RECURSIVE path(id, parent_id, depth) AS (
-        SELECT id, parent_id, 0 FROM assistant_messages WHERE id = ${leafId}
-        UNION ALL
-        SELECT m.id, m.parent_id, p.depth + 1 FROM assistant_messages m
-        JOIN path p ON m.id = p.parent_id
-        WHERE m.session_id = ${this.sessionId} AND p.depth < 10000
-      )
-      SELECT path.id AS id, am.role AS role, LENGTH(CAST(am.content AS BLOB)) AS bytes
-      FROM path JOIN assistant_messages am ON am.id = path.id
-      ORDER BY path.depth DESC
-    `;
-	}
-	/**
-	* Fetch and parse message content for an ordered list of path rows.
-	*
-	* Content is read in chunks bounded by both row count and cumulative
-	* stored bytes (no ORDER BY — SQLite streams rows without materializing
-	* the result set) and reassembled in path order. Rows that fail to parse
-	* are skipped, matching previous behavior.
-	*/
-	messagesByPathStats(rows) {
-		const contentById = /* @__PURE__ */ new Map();
-		const fetchChunk = (ids) => {
-			const fetched = this.agent.sql`
-        SELECT id, content FROM assistant_messages
-        WHERE session_id = ${this.sessionId}
-          AND id IN (SELECT value FROM json_each(${JSON.stringify(ids)}))
-      `;
-			for (const row of fetched) contentById.set(row.id, row.content);
-		};
-		let chunk = [];
-		let chunkBytes = 0;
-		for (const row of rows) {
-			if (chunk.length > 0 && (chunk.length >= HISTORY_CONTENT_CHUNK_SIZE || chunkBytes + row.bytes > HISTORY_CONTENT_CHUNK_BYTES)) {
-				fetchChunk(chunk);
-				chunk = [];
-				chunkBytes = 0;
-			}
-			chunk.push(row.id);
-			chunkBytes += row.bytes;
-		}
-		if (chunk.length > 0) fetchChunk(chunk);
-		const result = [];
-		for (const row of rows) {
-			const content = contentById.get(row.id);
-			if (content === void 0) continue;
-			const msg = this.parse(content);
-			if (msg) result.push(msg);
-		}
-		return result;
-	}
-	indexFTS(message) {
-		const text = message.parts.filter((p) => p.type === "text").map((p) => p.text).join(" ");
-		this.deleteFTS(message.id);
-		if (text) this.agent.sql`
-        INSERT INTO assistant_fts (id, session_id, role, content)
-        VALUES (${message.id}, ${this.sessionId}, ${message.role}, ${text})
-      `;
-	}
-	deleteFTS(id) {
-		const rows = this.agent.sql`
-      SELECT rowid FROM assistant_fts WHERE id = ${id} AND session_id = ${this.sessionId}
-    `;
-		for (const row of rows) this.agent.sql`DELETE FROM assistant_fts WHERE rowid = ${row.rowid}`;
-	}
-	applyCompactions(messages, compactions) {
-		const ids = messages.map((m) => m.id);
-		const result = [];
-		let i = 0;
-		while (i < messages.length) {
-			const matching = compactions.filter((c) => c.fromMessageId === ids[i]);
-			const comp = matching.length > 1 ? matching[matching.length - 1] : matching[0];
-			if (comp) {
-				const endIdx = ids.indexOf(comp.toMessageId);
-				if (endIdx >= i) {
-					result.push({
-						id: `${COMPACTION_PREFIX}${comp.id}`,
-						role: "assistant",
-						parts: [{
-							type: "text",
-							text: comp.summary
-						}],
-						createdAt: /* @__PURE__ */ new Date()
-					});
-					i = endIdx + 1;
-					continue;
-				}
-			}
-			result.push(messages[i]);
-			i++;
-		}
-		return result;
-	}
-	parse(json) {
-		try {
-			const msg = JSON.parse(json);
-			if (typeof msg?.id === "string" && typeof msg?.role === "string" && Array.isArray(msg?.parts)) return msg;
-		} catch {}
-		return null;
-	}
-	parseRows(rows) {
-		const result = [];
-		for (const row of rows) {
-			const msg = this.parse(row.content);
-			if (msg) result.push(msg);
-		}
-		return result;
-	}
-};
-//#endregion
-//#region src/experimental/memory/session/providers/agent-context.ts
-var AgentContextProvider = class {
-	constructor(agent, label) {
-		this.initialized = false;
-		this.agent = agent;
-		this.label = label ?? "";
-	}
-	init(label) {
-		if (!this.label) this.label = label;
-	}
-	ensureTable() {
-		if (this.initialized) return;
-		this.agent.sql`
-      CREATE TABLE IF NOT EXISTS cf_agents_context_blocks (
-        label TEXT PRIMARY KEY,
-        content TEXT NOT NULL,
-        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-		this.initialized = true;
-	}
-	async get() {
-		this.ensureTable();
-		return this.agent.sql`
-      SELECT content FROM cf_agents_context_blocks WHERE label = ${this.label}
-    `[0]?.content ?? null;
-	}
-	async set(content) {
-		this.ensureTable();
-		this.agent.sql`
-      INSERT INTO cf_agents_context_blocks (label, content)
-      VALUES (${this.label}, ${content})
-      ON CONFLICT(label) DO UPDATE SET content = ${content}, updated_at = CURRENT_TIMESTAMP
-    `;
-	}
-};
-//#endregion
-//#region src/experimental/memory/session/session.ts
-function isBroadcaster(obj) {
-	return typeof obj === "object" && obj !== null && "broadcast" in obj && typeof obj.broadcast === "function";
-}
-function isSqlProvider(arg) {
-	return "sql" in arg && typeof arg.sql === "function";
-}
-var Session = class Session {
-	constructor(storage, options) {
-		this._warnedCompactionNoOp = false;
-		this._ready = false;
-		this._skillScanRan = false;
-		this._warnedNoRecentHistorySupport = false;
-		this.storage = storage;
-		this.context = new ContextBlocks(options?.context ?? [], options?.promptStore);
-		this._tokenCounter = options?.tokenCounter;
-		this._compactionErrorHandler = options?.onCompactionError;
-		this._ready = true;
-	}
-	/**
-	* Chainable session creation with auto-wired providers.
-	*
-	* Pass a `SqlProvider` (Agent with `sql` method) for auto-wired SQLite,
-	* or a `SessionProvider` directly for custom storage (Postgres, etc.).
-	*
-	* @example
-	* ```ts
-	* // Auto-wired SQLite (DO Agent)
-	* const session = Session.create(this)
-	*   .withContext("soul", { provider: { get: async () => "You are helpful." } })
-	*   .withContext("memory", { description: "Learned facts", maxTokens: 1100 })
-	*   .withCachedPrompt();
-	*
-	* // Skills from R2 (on-demand loading via load_context tool)
-	* const session = Session.create(this)
-	*   .withContext("skills", {
-	*     provider: new R2SkillProvider(env.SKILLS_BUCKET, { prefix: "skills/" })
-	*   })
-	*   .withCachedPrompt();
-	*
-	* // Custom storage provider (Postgres, etc.)
-	* const session = Session.create(postgresProvider)
-	*   .withContext("memory", {
-	*     maxTokens: 1100,
-	*     provider: new PostgresContextProvider(conn, "memory")
-	*   })
-	*   .withCachedPrompt(new PostgresContextProvider(conn, "_prompt"));
-	* ```
-	*/
-	static create(provider) {
-		const session = Object.create(Session.prototype);
-		if (isSqlProvider(provider)) {
-			session._agent = provider;
-			if (isBroadcaster(provider)) session._broadcaster = provider;
-		} else session._storageProvider = provider;
-		session._pending = [];
-		session._ready = false;
-		return session;
-	}
-	forSession(sessionId) {
-		this._sessionId = sessionId;
-		return this;
-	}
-	withContext(label, options) {
-		this._pending.push({
-			label,
-			options: options ?? {}
-		});
-		return this;
-	}
-	withCachedPrompt(provider) {
-		this._cachedPrompt = provider ?? true;
-		return this;
-	}
-	/**
-	* Register a compaction function. Called by `compact()` to compress
-	* message history into a summary overlay.
-	*/
-	onCompaction(fn) {
-		this._compactionFn = fn;
-		return this;
-	}
-	/**
-	* Auto-compact when estimated token count exceeds the threshold.
-	* Checked after each `appendMessage`. Requires `onCompaction()`.
-	*
-	* By default this uses a Workers-safe heuristic over stored messages plus
-	* the Session-managed frozen system prompt. Provide `tokenCounter` when you
-	* have model-reported usage or a tokenizer and need a stricter budget.
-	*/
-	compactAfter(tokenThreshold, options) {
-		this._tokenThreshold = tokenThreshold;
-		if (options?.tokenCounter) this._tokenCounter = options.tokenCounter;
-		return this;
-	}
-	/**
-	* Handle failures from the automatic `compactAfter()` trigger.
-	*
-	* Manual `compact()` still reports errors through the existing session error
-	* broadcast path.
-	*/
-	onCompactionError(handler) {
-		this._compactionErrorHandler = handler;
-		return this;
-	}
-	/**
-	* @internal
-	* Framework hook for cache-owning callers that need to mirror message
-	* storage changes. Application code should use the normal Session methods.
-	*/
-	internal_onMessagesChanged(listener) {
-		this._messageChangeListener = listener ?? void 0;
-		return this;
-	}
-	_ensureReady() {
-		if (this._ready) return;
-		const configs = (this._pending ?? []).map(({ label, options: opts }) => {
-			let provider = opts.provider;
-			if (!provider && this._agent) {
-				const key = this._sessionId ? `${label}_${this._sessionId}` : label;
-				provider = new AgentContextProvider(this._agent, key);
-			}
-			return {
-				label,
-				description: opts.description,
-				maxTokens: opts.maxTokens,
-				provider
-			};
-		});
-		let promptStore;
-		if (this._cachedPrompt === true && this._agent) {
-			const key = this._sessionId ? `_system_prompt_${this._sessionId}` : "_system_prompt";
-			promptStore = new AgentContextProvider(this._agent, key);
-		} else if (this._cachedPrompt && this._cachedPrompt !== true) promptStore = this._cachedPrompt;
-		if (this._storageProvider) this.storage = this._storageProvider;
-		else if (this._agent) this.storage = new AgentSessionProvider(this._agent, this._sessionId);
-		else throw new Error("Session.create() requires a SqlProvider or SessionProvider");
-		this.context = new ContextBlocks(configs, promptStore);
-		this.context.setUnloadCallback((label, key) => {
-			this._reclaimLoadedSkill(label, key).catch(() => {});
-		});
-		this._ready = true;
-		this._restorePromise = this._restoreLoadedSkills().catch(() => {});
-	}
-	/**
-	* Await the background skill-restore kicked off by `_ensureReady()`.
-	* Idempotent and cheap — every async public method calls this so that
-	* `_loadedSkills` reflects conversation history before any read or write.
-	*/
-	async _ensureRestored() {
-		this._ensureReady();
-		if (this._restorePromise) await this._restorePromise;
-	}
-	async _notifyMessagesChanged(event) {
-		await this._messageChangeListener?.(event);
-	}
-	/**
-	* Reconstruct which skills are loaded by scanning conversation history
-	* for load_context tool results that haven't been unloaded.
-	* Runs once per init to survive hibernation / eviction, including for
-	* async SessionProviders (e.g. Postgres) where we must `await` history.
-	*
-	* Skipped entirely when no skill-capable provider is configured —
-	* `load_context` results can only exist when a skill block was registered,
-	* and the scan would otherwise read the whole transcript on every wake,
-	* bypassing byte-budgeted hydration (#1710). A skill block added later via
-	* `addContext()` triggers the scan at that point instead.
-	*/
-	async _restoreLoadedSkills() {
-		if (!this.context.hasSkillCapableConfigs()) return;
-		await this._scanHistoryForLoadedSkills();
-	}
-	/**
-	* Scan stored history for load/unload_context tool results and restore
-	* the loaded-skill tracking set.
-	*
-	* Memory-bounded when the provider supports `getHistoryRowStats`: rows
-	* are enumerated without content, then only assistant rows are fetched
-	* and scanned ONE AT A TIME — peak memory is a single message instead of
-	* the whole transcript. Falls back to a full `getHistory()` read for
-	* providers without row stats (e.g. Postgres).
-	*
-	* Note: the bounded path scans raw path rows, so `load_context` results
-	* inside compacted ranges are still seen (the full-read path hides them
-	* behind compaction overlays). That superset is intentional — the stored
-	* tool result still exists and can be reclaimed by `unloadSkill`.
-	*/
-	async _scanHistoryForLoadedSkills() {
-		this._skillScanRan = true;
-		const loaded = /* @__PURE__ */ new Set();
-		const scanMessage = (msg) => {
-			if (msg.role !== "assistant") return;
-			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 (this.storage.getHistoryRowStats) {
-			const stats = await this.storage.getHistoryRowStats();
-			for (const row of stats) {
-				if (row.role !== "assistant") continue;
-				const msg = await this.storage.getMessage(row.id);
-				if (msg) scanMessage(msg);
-			}
-		} else for (const msg of await this.storage.getHistory()) scanMessage(msg);
-		if (loaded.size > 0) this.context.restoreLoadedSkills(loaded);
-	}
-	/**
-	* Reclaim context-window tokens consumed by a previously loaded skill.
-	*
-	* When a skill is loaded via the `load_context` tool, its full body is
-	* embedded as that tool call's `output-available` result inside the
-	* assistant message — which means every subsequent turn replays the
-	* entire skill as part of the conversation history and pays for it in
-	* input tokens.
-	*
-	* This method walks back through history, finds the matching
-	* `load_context` tool result for `(label, key)`, and replaces its bulky
-	* `output` with a short marker `[skill unloaded: <key>]`. The skill
-	* content is dropped from future turns and the tokens are reclaimed.
-	* The skill itself stays available to reload via `load_context`.
-	*/
-	async _reclaimLoadedSkill(label, key) {
-		const history = await 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) {
-				await this.updateMessage({
-					...msg,
-					parts: newParts
-				});
-				return;
-			}
-		}
-	}
-	async getHistory(leafId) {
-		await this._ensureRestored();
-		return this.storage.getHistory(leafId);
-	}
-	/**
-	* Byte-budgeted read of the most recent messages on the active branch
-	* path (always at least the leaf message, and at least
-	* `minRecentMessages` when the path is long enough). Lets hosts hydrate
-	* a bounded window instead of the full transcript so wake-time memory
-	* scales with the budget rather than total session history (#1710).
-	*
-	* Falls back to a full (untruncated) read when the provider doesn't
-	* implement `getRecentHistory`. The fallback reports honest metadata
-	* (`truncated: false` and the real serialized size) and warns once so a
-	* host relying on the budget knows it is not being enforced.
-	*/
-	async getRecentHistory(maxContentBytes, minRecentMessages = 1) {
-		await this._ensureRestored();
-		if (this.storage.getRecentHistory) return this.storage.getRecentHistory(null, maxContentBytes, minRecentMessages);
-		if (!this._warnedNoRecentHistorySupport) {
-			this._warnedNoRecentHistorySupport = true;
-			console.warn("[Session] The configured SessionProvider does not implement getRecentHistory; the requested byte budget cannot be enforced and the FULL history was loaded. Implement getRecentHistory (and getHistoryRowStats) on the provider to bound hydration.");
-		}
-		const messages = await this.storage.getHistory();
-		let totalContentBytes = 0;
-		for (const message of messages) totalContentBytes += JSON.stringify(message).length;
-		return {
-			messages,
-			truncated: false,
-			totalContentBytes
-		};
-	}
-	/**
-	* Per-row stored sizes for the active branch path (root → leaf) WITHOUT
-	* loading message content, or `null` when the provider doesn't support it.
-	* Lets hosts find oversized rows (e.g. inline base64 media) and process
-	* them one at a time with bounded memory.
-	*/
-	async getHistoryRowStats() {
-		await this._ensureRestored();
-		if (!this.storage.getHistoryRowStats) return null;
-		return this.storage.getHistoryRowStats();
-	}
-	async getMessage(id) {
-		await this._ensureRestored();
-		return this.storage.getMessage(id);
-	}
-	async getLatestLeaf() {
-		await this._ensureRestored();
-		return this.storage.getLatestLeaf();
-	}
-	async getBranches(messageId) {
-		await this._ensureRestored();
-		return this.storage.getBranches(messageId);
-	}
-	async getPathLength(leafId) {
-		await this._ensureRestored();
-		return this.storage.getPathLength(leafId);
-	}
-	_broadcast(type, data) {
-		if (!this._broadcaster) return;
-		this._broadcaster.broadcast(JSON.stringify({
-			type,
-			...data
-		}));
-	}
-	_shouldEstimateTokens() {
-		return Boolean(this._broadcaster || this._tokenThreshold != null && this._compactionFn);
-	}
-	async _estimateTokenCount() {
-		const messages = await this.getHistory();
-		const systemPrompt = await this.context.getSystemPromptForEstimate();
-		if (this._tokenCounter) {
-			if (!this.context.isLoaded()) await this.context.load();
-			const contextBlocks = this.context.getBlocks();
-			const estimate = await this._tokenCounter({
-				messages,
-				systemPrompt,
-				contextBlocks
-			});
-			return Number.isFinite(estimate) ? Math.max(0, Math.ceil(estimate)) : 0;
-		}
-		return estimateMessageTokens(messages) + estimateStringTokens(systemPrompt);
-	}
-	async _handleAutoCompactionError(error) {
-		const message = error instanceof Error ? error.message : String(error);
-		if (this._compactionErrorHandler) try {
-			await this._compactionErrorHandler(error);
-		} catch (handlerError) {
-			const handlerMessage = handlerError instanceof Error ? handlerError.message : String(handlerError);
-			console.warn(`Session auto-compaction error handler failed: ${handlerMessage}`);
-		}
-		else console.warn(`Session auto-compaction failed: ${message}`);
-		this._emitError(message);
-	}
-	async _emitStatus(phase, extra) {
-		let tokenEstimate = 0;
-		if (this._shouldEstimateTokens()) try {
-			tokenEstimate = await this._estimateTokenCount();
-		} catch (err) {
-			await this._handleAutoCompactionError(err);
-		}
-		this._broadcast("cf_agent_session", {
-			phase,
-			tokenEstimate,
-			tokenThreshold: this._tokenThreshold ?? null,
-			...extra
-		});
-		return tokenEstimate;
-	}
-	_emitError(error) {
-		this._broadcast("cf_agent_session_error", { error });
-	}
-	async appendMessage(message, parentId) {
-		await this._appendMessage(message, parentId);
-	}
-	async _appendMessage(message, parentId) {
-		await this._ensureRestored();
-		if (await this.storage.getMessage(message.id)) {
-			await this._emitStatus("idle");
-			await this._notifyMessagesChanged({
-				type: "append",
-				message,
-				parentId,
-				inserted: false
-			});
-			return;
-		}
-		await this.storage.appendMessage(message, parentId);
-		const tokenEstimate = await this._emitStatus("idle");
-		let compacted = false;
-		if (this._tokenThreshold != null && this._compactionFn && tokenEstimate > this._tokenThreshold) try {
-			compacted = Boolean(await this.compact());
-			if (!compacted && !this._warnedCompactionNoOp) {
-				this._warnedCompactionNoOp = true;
-				console.warn(`[Session] Auto-compaction fired (~${tokenEstimate} tokens > ${this._tokenThreshold}) but the compaction function returned null, so history was not shortened. ` + (this._tokenCounter ? `A tokenCounter is configured and now flows to the boundary logic, but it is invoked per-message there — a whole-prompt/usage counter (e.g. returning a fixed usage.inputTokens regardless of which messages are passed) degrades the tail budget to minTailMessages and can still no-op. Pass a per-message CompactOptions.tokenCounter for precise tail budgeting.` : `If your history is tool-heavy, configure a tokenCounter on compactAfter() — it flows to createCompactFunction's boundary logic automatically.`));
-			} else if (compacted) this._warnedCompactionNoOp = false;
-		} catch (err) {
-			await this._handleAutoCompactionError(err);
-		}
-		if (!compacted) await this._notifyMessagesChanged({
-			type: "append",
-			message,
-			parentId,
-			inserted: true
-		});
-	}
-	async updateMessage(message) {
-		await this._ensureRestored();
-		await this.storage.updateMessage(message);
-		await this._emitStatus("idle");
-		await this._notifyMessagesChanged({
-			type: "update",
-			message
-		});
-	}
-	/**
-	* @internal
-	* Rewrite a stored message WITHOUT the public-write side effects: no
-	* token-estimate status broadcast (which reads the FULL history) and no
-	* auto-compaction check. For framework maintenance passes that rewrite
-	* many rows with bounded memory — e.g. media eviction (#1710) — where the
-	* per-row full-history estimate would reintroduce the memory pressure the
-	* pass exists to remove. The message-change listener still fires so a
-	* cache-owning host stays coherent. Application code should use
-	* `updateMessage`.
-	*/
-	async internal_rewriteMessage(message) {
-		await this._ensureRestored();
-		await this.storage.updateMessage(message);
-		await this._notifyMessagesChanged({
-			type: "update",
-			message
-		});
-	}
-	async deleteMessages(messageIds) {
-		await this._ensureRestored();
-		await this.storage.deleteMessages(messageIds);
-		await this._emitStatus("idle");
-		await this._notifyMessagesChanged({
-			type: "delete",
-			messageIds
-		});
-	}
-	async clearMessages() {
-		await this._ensureRestored();
-		await this.storage.clearMessages();
-		this.context.clearSkillState();
-		await this.context.refreshSystemPrompt();
-		await this._emitStatus("idle");
-		await this._notifyMessagesChanged({ type: "clear" });
-	}
-	async addCompaction(summary, fromMessageId, toMessageId) {
-		await this._ensureRestored();
-		return this.storage.addCompaction(summary, fromMessageId, toMessageId);
-	}
-	async getCompactions() {
-		await this._ensureRestored();
-		return this.storage.getCompactions();
-	}
-	/**
-	* Run the registered compaction function and store the result as an overlay.
-	* Requires `onCompaction()` to be called first.
-	*/
-	async compact() {
-		await this._ensureRestored();
-		if (!this._compactionFn) throw new Error("No compaction function registered. Call onCompaction() first.");
-		const tokensBefore = await this._emitStatus("compacting");
-		let result;
-		try {
-			result = await this._compactionFn(await this.getHistory(), { tokenCounter: this._tokenCounter });
-		} catch (err) {
-			this._emitError(err instanceof Error ? err.message : String(err));
-			return null;
-		}
-		if (!result) {
-			await this._emitStatus("idle");
-			return null;
-		}
-		if (!new Set((await this.getHistory()).map((m) => m.id)).has(result.toMessageId)) {
-			await this._emitStatus("idle");
-			return null;
-		}
-		const existing = await this.getCompactions();
-		const fromId = existing.length > 0 ? existing[0].fromMessageId : result.fromMessageId;
-		await this.addCompaction(result.summary, fromId, result.toMessageId);
-		await this.refreshSystemPrompt();
-		await this._emitStatus("idle", { compacted: { tokensBefore } });
-		await this._notifyMessagesChanged({ type: "compact" });
-		return {
-			...result,
-			fromMessageId: fromId
-		};
-	}
-	getContextBlock(label) {
-		this._ensureReady();
-		return this.context.getBlock(label);
-	}
-	getContextBlocks() {
-		this._ensureReady();
-		return this.context.getBlocks();
-	}
-	async replaceContextBlock(label, content) {
-		await this._ensureRestored();
-		return this.context.setBlock(label, content);
-	}
-	async appendContextBlock(label, content) {
-		await this._ensureRestored();
-		return this.context.appendToBlock(label, content);
-	}
-	/**
-	* Dynamically register a new context block after session initialization.
-	*
-	* This is a **builder / runtime API**, not an LLM tool. The LLM writes
-	* into existing context blocks via the `set_context` tool (see
-	* `ContextBlocks.tools()`); it cannot declare new blocks itself. This
-	* method is how extension / host code contributes blocks at runtime
-	* (e.g. an extension's `onLoad` handler registering its own memory block).
-	*
-	* 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) {
-		await this._ensureRestored();
-		const opts = options ?? {};
-		let provider = opts.provider;
-		if (!provider) {
-			if (!this._agent) throw new Error(`addContext("${label}") requires an explicit provider when Session uses a SessionProvider`);
-			const key = this._sessionId ? `${label}_${this._sessionId}` : label;
-			provider = new AgentContextProvider(this._agent, key);
-		}
-		const block = await this.context.addBlock({
-			label,
-			description: opts.description,
-			maxTokens: opts.maxTokens,
-			provider
-		});
-		if (block.isSkill && !this._skillScanRan) await this._scanHistoryForLoadedSkills();
-		return block;
-	}
-	/**
-	* 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.
-	*
-	* Async so that the session's background skill-state restore (which
-	* reads conversation history) is awaited first — otherwise a freshly
-	* rehydrated DO could report "not loaded" for a skill that's actually
-	* present in history.
-	*/
-	async unloadSkill(label, key) {
-		await this._ensureRestored();
-		return this.context.unloadSkill(label, key);
-	}
-	/**
-	* Get currently loaded skill keys (as "label:key" strings).
-	* Async for the same reason as `unloadSkill` — must wait for restore.
-	*/
-	async getLoadedSkillKeys() {
-		await this._ensureRestored();
-		return this.context.getLoadedSkillKeys();
-	}
-	async freezeSystemPrompt() {
-		await this._ensureRestored();
-		return this.context.freezeSystemPrompt();
-	}
-	async refreshSystemPrompt() {
-		await this._ensureRestored();
-		return this.context.refreshSystemPrompt();
-	}
-	async search(query, options) {
-		await this._ensureRestored();
-		if (!this.storage.searchMessages) throw new Error("Session provider does not support search");
-		return this.storage.searchMessages(query, options?.limit ?? 20);
-	}
-	/** Returns set_context and load_context tools. */
-	async tools() {
-		await this._ensureRestored();
-		return this.context.tools();
-	}
-};
-//#endregion
-//#region src/experimental/memory/session/manager.ts
-var SessionManager = class SessionManager {
-	constructor(agent, _options = {}) {
-		this._pending = [];
-		this._sessions = /* @__PURE__ */ new Map();
-		this._tableReady = false;
-		this._ready = false;
-		this.agent = agent;
-		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()
-	*   .compactAfter(100_000);
-	*
-	* // 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._pending = [];
-		mgr._compactionFn = null;
-		mgr._tokenThreshold = void 0;
-		mgr._tokenCounter = void 0;
-		mgr._compactionErrorHandler = 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;
-	}
-	/**
-	* 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, options) {
-		this._tokenThreshold = tokenThreshold;
-		if (options?.tokenCounter) this._tokenCounter = options.tokenCounter;
-		return this;
-	}
-	/**
-	* Handle failures from automatic compaction in managed sessions.
-	*/
-	onCompactionError(handler) {
-		this._compactionErrorHandler = handler;
-		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, { tokenCounter: this._tokenCounter });
-			if (this._compactionErrorHandler) s.onCompactionError(this._compactionErrorHandler);
-			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
-    `;
-	}
-	async delete(sessionId) {
-		await 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 (await session.getMessage(message.id)) await 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;
-	}
-	async getHistory(sessionId, leafId) {
-		return this.getSession(sessionId).getHistory(leafId);
-	}
-	async getMessageCount(sessionId) {
-		return this.getSession(sessionId).getPathLength();
-	}
-	async clearMessages(sessionId) {
-		await this.getSession(sessionId).clearMessages();
-		this._touch(sessionId);
-	}
-	async deleteMessages(sessionId, messageIds) {
-		await this.getSession(sessionId).deleteMessages(messageIds);
-		this._touch(sessionId);
-	}
-	async 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 = await 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;
-	}
-	async addCompaction(sessionId, summary, fromId, toId) {
-		return this.getSession(sessionId).addCompaction(summary, fromId, toId);
-	}
-	async 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: z.fromJSONSchema({
-				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
-//#region src/experimental/memory/session/providers/postgres-adapter.ts
-function isPostgresConnection(client) {
-	return typeof client.execute === "function";
-}
-/**
-* Normalise an incoming client into a `PostgresConnection`. When given a
-* `pg`-style client we translate `?` placeholders to `$1, $2, ...` so the
-* providers can keep using the portable `?` syntax internally.
-*/
-function toPostgresConnection(client) {
-	if (isPostgresConnection(client)) return client;
-	const pg = client;
-	return { async execute(query, args) {
-		let idx = 0;
-		const pgQuery = query.replace(/\?/g, () => `$${++idx}`);
-		return { rows: (await pg.query(pgQuery, args ?? [])).rows };
-	} };
-}
-//#endregion
-//#region src/experimental/memory/session/providers/postgres.ts
-var PostgresSessionProvider = class {
-	/**
-	* @param client A raw `pg.Client` (recommended) or any `PostgresConnection`.
-	*   Must already be connected — this provider never opens or closes the
-	*   underlying client.
-	* @param sessionId Session identifier. Different ids are fully isolated
-	*   rows within the shared tables. Defaults to `""`.
-	*/
-	constructor(client, sessionId) {
-		this.conn = toPostgresConnection(client);
-		this.sessionId = sessionId ?? "";
-	}
-	async getMessage(id) {
-		const { rows } = await this.conn.execute("SELECT content FROM assistant_messages WHERE id = ? AND session_id = ?", [id, this.sessionId]);
-		return rows.length > 0 ? this.parse(rows[0].content) : null;
-	}
-	async getHistory(leafId) {
-		const leaf = leafId ? (await this.conn.execute("SELECT id FROM assistant_messages WHERE id = ? AND session_id = ?", [leafId, this.sessionId])).rows[0] : await this.latestLeafRow();
-		if (!leaf) return [];
-		const { rows } = await this.conn.execute(`WITH RECURSIVE path AS (
-        SELECT id, parent_id, content, 0 as depth FROM assistant_messages WHERE id = ? AND session_id = ?
-        UNION ALL
-        SELECT m.id, m.parent_id, m.content, p.depth + 1 FROM assistant_messages m
-        JOIN path p ON m.id = p.parent_id
-        WHERE m.session_id = ? AND p.depth < 10000
-      )
-      SELECT content FROM path ORDER BY depth DESC`, [
-			leaf.id,
-			this.sessionId,
-			this.sessionId
-		]);
-		const messages = this.parseRows(rows);
-		const compactions = await this.getCompactions();
-		if (compactions.length === 0) return messages;
-		return this.applyCompactions(messages, compactions);
-	}
-	async getLatestLeaf() {
-		const row = await this.latestLeafRow();
-		return row ? this.parse(row.content) : null;
-	}
-	async getBranches(messageId) {
-		const { rows } = await this.conn.execute("SELECT content FROM assistant_messages WHERE parent_id = ? AND session_id = ? ORDER BY created_at ASC", [messageId, this.sessionId]);
-		return this.parseRows(rows);
-	}
-	async getPathLength(leafId) {
-		const leaf = leafId ? (await this.conn.execute("SELECT id FROM assistant_messages WHERE id = ? AND session_id = ?", [leafId, this.sessionId])).rows[0] : await this.latestLeafRow();
-		if (!leaf) return 0;
-		const { rows } = await this.conn.execute(`WITH RECURSIVE path AS (
-        SELECT id, parent_id, 0 as depth FROM assistant_messages WHERE id = ? AND session_id = ?
-        UNION ALL
-        SELECT m.id, m.parent_id, p.depth + 1 FROM assistant_messages m
-        JOIN path p ON m.id = p.parent_id
-        WHERE m.session_id = ? AND p.depth < 10000
-      )
-      SELECT COUNT(*) as count FROM path`, [
-			leaf.id,
-			this.sessionId,
-			this.sessionId
-		]);
-		return Number(rows[0]?.count ?? 0);
-	}
-	async appendMessage(message, parentId) {
-		let parent = parentId !== void 0 ? parentId : (await this.latestLeafRow())?.id ?? null;
-		if (parent) {
-			const { rows } = await this.conn.execute("SELECT id FROM assistant_messages WHERE id = ? AND session_id = ?", [parent, this.sessionId]);
-			if (rows.length === 0) parent = null;
-		}
-		const json = JSON.stringify(message);
-		const text = this.extractSearchableText(json);
-		await this.conn.execute(`INSERT INTO assistant_messages (id, session_id, parent_id, role, content, text_content)
-       VALUES (?, ?, ?, ?, ?, ?)
-       ON CONFLICT (session_id, id) DO NOTHING`, [
-			message.id,
-			this.sessionId,
-			parent,
-			message.role,
-			json,
-			text
-		]);
-	}
-	async updateMessage(message) {
-		const json = JSON.stringify(message);
-		await this.conn.execute("UPDATE assistant_messages SET content = ?, text_content = ? WHERE id = ? AND session_id = ?", [
-			json,
-			this.extractSearchableText(json),
-			message.id,
-			this.sessionId
-		]);
-	}
-	async deleteMessages(messageIds) {
-		for (const id of messageIds) await this.conn.execute("DELETE FROM assistant_messages WHERE id = ? AND session_id = ?", [id, this.sessionId]);
-	}
-	async clearMessages() {
-		await this.conn.execute("DELETE FROM assistant_messages WHERE session_id = ?", [this.sessionId]);
-		await this.conn.execute("DELETE FROM assistant_compactions WHERE session_id = ?", [this.sessionId]);
-	}
-	async addCompaction(summary, fromMessageId, toMessageId) {
-		const id = crypto.randomUUID();
-		await this.conn.execute("INSERT INTO assistant_compactions (id, session_id, summary, from_message_id, to_message_id) VALUES (?, ?, ?, ?, ?)", [
-			id,
-			this.sessionId,
-			summary,
-			fromMessageId,
-			toMessageId
-		]);
-		return {
-			id,
-			summary,
-			fromMessageId,
-			toMessageId,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-	}
-	async getCompactions() {
-		const { rows } = await this.conn.execute("SELECT * FROM assistant_compactions WHERE session_id = ? ORDER BY created_at ASC", [this.sessionId]);
-		return rows.map((r) => ({
-			id: r.id,
-			summary: r.summary,
-			fromMessageId: r.from_message_id,
-			toMessageId: r.to_message_id,
-			createdAt: r.created_at instanceof Date ? r.created_at.toISOString() : String(r.created_at)
-		}));
-	}
-	async searchMessages(query, limit = 20) {
-		const { rows } = await this.conn.execute(`SELECT id, role, text_content FROM assistant_messages
-       WHERE session_id = ? AND content_tsv @@ plainto_tsquery('english', ?)
-       ORDER BY ts_rank(content_tsv, plainto_tsquery('english', ?)) DESC
-       LIMIT ?`, [
-			this.sessionId,
-			query,
-			query,
-			limit
-		]);
-		return rows.map((r) => ({
-			id: r.id,
-			role: r.role,
-			content: r.text_content ?? "",
-			createdAt: ""
-		}));
-	}
-	async latestLeafRow() {
-		const { rows } = await this.conn.execute(`SELECT m.id, m.content FROM assistant_messages m
-       LEFT JOIN assistant_messages c ON c.parent_id = m.id AND c.session_id = ?
-       WHERE c.id IS NULL AND m.session_id = ?
-       ORDER BY m.created_at DESC LIMIT 1`, [this.sessionId, this.sessionId]);
-		return rows[0] ?? null;
-	}
-	applyCompactions(messages, compactions) {
-		const ids = messages.map((m) => m.id);
-		const result = [];
-		let i = 0;
-		while (i < messages.length) {
-			const matching = compactions.filter((c) => c.fromMessageId === ids[i]);
-			const comp = matching.length > 1 ? matching[matching.length - 1] : matching[0];
-			if (comp) {
-				const endIdx = ids.indexOf(comp.toMessageId);
-				if (endIdx >= i) {
-					result.push({
-						id: `compaction_${comp.id}`,
-						role: "assistant",
-						parts: [{
-							type: "text",
-							text: comp.summary
-						}],
-						createdAt: /* @__PURE__ */ new Date()
-					});
-					i = endIdx + 1;
-					continue;
-				}
-			}
-			result.push(messages[i]);
-			i++;
-		}
-		return result;
-	}
-	parse(json) {
-		try {
-			const msg = JSON.parse(json);
-			if (typeof msg?.id === "string" && typeof msg?.role === "string" && Array.isArray(msg?.parts)) return msg;
-		} catch {}
-		return null;
-	}
-	parseRows(rows) {
-		const result = [];
-		for (const row of rows) {
-			const msg = this.parse(row.content);
-			if (msg) result.push(msg);
-		}
-		return result;
-	}
-	/**
-	* Extract just the human-readable text from a message's JSON blob
-	* and store it in `text_content`, which feeds the generated `content_tsv`
-	* column used for FTS. The full structured message (parts, tool calls,
-	* metadata) is still stored verbatim in `content` — this is the source
-	* of truth. Indexing the raw JSON would return FTS hits on keys like
-	* `"role"`, `"parts"`, `"dynamic-tool"`, etc.
-	*/
-	extractSearchableText(json) {
-		const msg = this.parse(json);
-		if (!msg) return json;
-		return msg.parts.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
-	}
-};
-//#endregion
-//#region src/experimental/memory/session/providers/postgres-context.ts
-var PostgresContextProvider = class {
-	/**
-	* @param client A raw `pg.Client` (recommended) or any `PostgresConnection`.
-	*   Must already be connected.
-	* @param label Block label used as the primary key row in
-	*   `cf_agents_context_blocks`. Pass a session-scoped label (e.g.
-	*   `` `memory_${sessionId}` ``) for per-session state.
-	*/
-	constructor(client, label) {
-		this.conn = toPostgresConnection(client);
-		this.label = label;
-	}
-	async get() {
-		const { rows } = await this.conn.execute("SELECT content FROM cf_agents_context_blocks WHERE label = ?", [this.label]);
-		return rows[0]?.content ?? null;
-	}
-	async set(content) {
-		await this.conn.execute(`INSERT INTO cf_agents_context_blocks (label, content)
-       VALUES (?, ?)
-       ON CONFLICT (label) DO UPDATE SET content = EXCLUDED.content, updated_at = NOW()`, [this.label, content]);
-	}
-};
-//#endregion
-//#region src/experimental/memory/session/providers/postgres-search.ts
-var PostgresSearchProvider = class {
-	/**
-	* @param client A raw `pg.Client` (recommended) or any `PostgresConnection`.
-	*   Must already be connected.
-	*/
-	constructor(client) {
-		this.label = "";
-		this.conn = toPostgresConnection(client);
-	}
-	init(label) {
-		this.label = label;
-	}
-	async get() {
-		const { rows } = await this.conn.execute("SELECT COUNT(*) as count FROM cf_agents_search_entries WHERE label = ?", [this.label]);
-		const count = Number(rows[0]?.count ?? 0);
-		if (count === 0) return null;
-		return `${count} entries indexed.`;
-	}
-	async search(query) {
-		if (!query.trim()) return null;
-		const { rows } = await this.conn.execute(`SELECT key, content FROM cf_agents_search_entries
-       WHERE label = ? AND content_tsv @@ plainto_tsquery('english', ?)
-       ORDER BY ts_rank(content_tsv, plainto_tsquery('english', ?)) DESC
-       LIMIT 10`, [
-			this.label,
-			query,
-			query
-		]);
-		if (rows.length === 0) return "No results found.";
-		return rows.map((r) => `[${r.key}]\n${r.content}`).join("\n\n");
-	}
-	async set(key, content) {
-		await this.conn.execute(`INSERT INTO cf_agents_search_entries (label, key, content)
-       VALUES (?, ?, ?)
-       ON CONFLICT (label, key) DO UPDATE SET
-         content = EXCLUDED.content,
-         updated_at = NOW()`, [
-			this.label,
-			key,
-			content
-		]);
-	}
-};
-//#endregion
-export { AgentContextProvider, AgentSearchProvider, AgentSessionProvider, PostgresContextProvider, PostgresSearchProvider, PostgresSessionProvider, R2SkillProvider, Session, SessionManager, isSearchProvider, isSkillProvider, isWritableProvider };
-
-//# sourceMappingURL=index.js.map