agent-worker 0.9.0 → 0.11.0

package/dist/index.mjs

@@ -1,7 +1,14 @@
-import { D as SUPPORTED_PROVIDERS, E as FRONTIER_MODELS, O as createModel, a as createMockBackend, c as CodexBackend, i as MockAIBackend, k as createModelAsync, l as ClaudeCodeBackend, n as createBackend, o as SdkBackend, r as listBackends, s as CursorBackend, t as checkBackends } from "./backends-BOAkfYyL.mjs";
-import { a as createSkillsTool, c as createFeedbackTool, i as parseImportSpec, l as AgentSession, n as buildGitUrl, o as SkillsProvider, r as getSpecDisplayName, s as FEEDBACK_PROMPT, t as SkillImporter } from "./skills-xNmQZf8e.mjs";
+import { A as createModelAsync, D as FRONTIER_MODELS, O as SUPPORTED_PROVIDERS, a as createMockBackend, c as CodexBackend, i as MockAIBackend, k as createModel, l as ClaudeCodeBackend, n as createBackend, o as SdkBackend, r as listBackends, s as CursorBackend, t as checkBackends } from "./backends-DLaP0rMW.mjs";
+import { t as AgentWorker } from "./worker-CJ5_b2_q.mjs";
 import { jsonSchema, tool } from "ai";
 import { createBashTool } from "bash-tool";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, normalize } from "node:path";
+import { parse } from "yaml";
+import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+import { z } from "zod";
+import { tmpdir } from "node:os";
+import { spawn } from "node:child_process";
 
 //#region src/agent/tools/bash.ts
 /**
@@ -10,7 +17,7 @@ import { createBashTool } from "bash-tool";
 * Provides bash, readFile, writeFile tools for AI agents in a sandboxed environment
 */
 /**
-* Create bash tools as AI SDK tool() objects for use with AgentSession
+* Create bash tools as AI SDK tool() objects for use with AgentWorker
 *
 * @example
 * ```typescript
@@ -18,7 +25,7 @@ import { createBashTool } from "bash-tool";
 *   files: { 'src/index.ts': 'console.log("hello")' }
 * })
 *
-* const session = new AgentSession({
+* const session = new AgentWorker({
 *   model: 'anthropic/claude-sonnet-4-5',
 *   system: 'You are a coding assistant.',
 *   tools
@@ -108,4 +115,553 @@ async function createBashToolsFromFiles(files, options = {}) {
 }
 
 //#endregion
-export { AgentSession, ClaudeCodeBackend, CodexBackend, CursorBackend, FEEDBACK_PROMPT, FRONTIER_MODELS, MockAIBackend, SUPPORTED_PROVIDERS, SdkBackend, SkillImporter, SkillsProvider, buildGitUrl, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createFeedbackTool, createMockBackend, createModel, createModelAsync, createSkillsTool, getSpecDisplayName, listBackends, parseImportSpec };
+//#region src/agent/tools/feedback.ts
+/**
+* Feedback tool — lets agents surface workflow improvement needs
+*
+* When enabled, agents can report what's missing or inconvenient during work:
+* a tool they wished they had, a step that felt unnecessarily slow, or a
+* capability gap. The purpose is workflow improvement, not bug reporting.
+*
+* @example
+* ```typescript
+* const { tool, getFeedback } = createFeedbackTool();
+*
+* const session = new AgentWorker({
+*   model: 'anthropic/claude-sonnet-4-5',
+*   system: FEEDBACK_PROMPT + '\nYou are a coding assistant.',
+*   tools: { feedback: tool, bash: bashTool },
+* });
+*
+* await session.send('...');
+* console.log(getFeedback()); // review what the agent reported
+* ```
+*/
+/**
+* Append this to the system prompt when the feedback tool is enabled.
+* Tells the agent the tool exists and when to use it.
+*/
+const FEEDBACK_PROMPT = `
+## Feedback
+
+You have a \`feedback\` tool. If you run into something inconvenient during your work — a tool you wish you had, a workflow step that feels unnecessarily slow, a capability gap — use it to report what you needed.
+
+The purpose is to improve the workflow for future runs. Don't force feedback; only call it when you genuinely hit a pain point.
+`.trim();
+function createFeedbackTool(options = {}) {
+	const { onFeedback, maxEntries = 50 } = options;
+	const entries = [];
+	return {
+		tool: tool({
+			description: "Report a workflow improvement need. Use when you hit something inconvenient — a missing tool, an awkward step, or a capability you wished you had.",
+			inputSchema: jsonSchema({
+				type: "object",
+				properties: {
+					target: {
+						type: "string",
+						description: "The area this is about — a tool name (e.g. bash, readFile), a workflow step, or a general area (e.g. file search, code review)."
+					},
+					type: {
+						type: "string",
+						enum: [
+							"missing",
+							"friction",
+							"suggestion"
+						],
+						description: "missing: a tool or capability you needed but didn't have. friction: something that works but is awkward or slow. suggestion: a concrete improvement idea."
+					},
+					description: {
+						type: "string",
+						description: "What you needed or what could be improved. Be specific."
+					},
+					context: {
+						type: "string",
+						description: "Optional: what you were trying to do when you hit this."
+					}
+				},
+				required: [
+					"target",
+					"type",
+					"description"
+				]
+			}),
+			execute: async (args) => {
+				const validTypes = [
+					"missing",
+					"friction",
+					"suggestion"
+				];
+				const rawType = args.type;
+				const type = validTypes.includes(rawType) ? rawType : "suggestion";
+				const entry = {
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					target: args.target,
+					type,
+					description: args.description,
+					...args.context ? { context: args.context } : {}
+				};
+				if (entries.length >= maxEntries) entries.shift();
+				entries.push(entry);
+				onFeedback?.(entry);
+				return { recorded: true };
+			}
+		}),
+		getFeedback: () => [...entries],
+		clearFeedback: () => {
+			entries.length = 0;
+		}
+	};
+}
+
+//#endregion
+//#region src/agent/skills/provider.ts
+const frontmatterSchema = z.object({
+	name: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).max(64),
+	description: z.string().min(1).max(1024),
+	license: z.string().optional(),
+	compatibility: z.string().max(500).optional(),
+	metadata: z.record(z.string()).optional(),
+	"allowed-tools": z.string().optional()
+});
+var SkillsProvider = class {
+	skills = /* @__PURE__ */ new Map();
+	/**
+	* Add a single skill directory
+	*/
+	async addSkill(skillPath) {
+		const skillMdPath = join(skillPath, "SKILL.md");
+		try {
+			await stat(skillMdPath);
+		} catch {
+			throw new Error(`SKILL.md not found in ${skillPath}`);
+		}
+		const frontmatter = await this.parseFrontmatter(skillMdPath);
+		this.skills.set(frontmatter.name, {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			path: skillPath
+		});
+	}
+	/**
+	* Scan a directory and add all valid skills found
+	*/
+	async scanDirectory(dir) {
+		const resolved = this.resolvePath(dir);
+		try {
+			const entries = await readdir(resolved, { withFileTypes: true });
+			for (const entry of entries) if (entry.isDirectory()) {
+				const skillPath = join(resolved, entry.name);
+				try {
+					await this.addSkill(skillPath);
+				} catch {}
+			}
+		} catch {}
+	}
+	/**
+	* List all available skills (metadata only)
+	*/
+	list() {
+		return Array.from(this.skills.values()).map(({ name, description }) => ({
+			name,
+			description
+		}));
+	}
+	/**
+	* View the full SKILL.md content
+	*/
+	async view(skillName) {
+		const skill = this.skills.get(skillName);
+		if (!skill) throw new Error(`Skill "${skillName}" not found`);
+		return await readFile(join(skill.path, "SKILL.md"), "utf-8");
+	}
+	/**
+	* Read a file within a skill directory (relative path)
+	*/
+	async readFile(skillName, relativePath) {
+		const skill = this.skills.get(skillName);
+		if (!skill) throw new Error(`Skill "${skillName}" not found`);
+		const normalized = normalize(relativePath);
+		if (normalized.startsWith("..")) throw new Error("Path traversal not allowed");
+		return await readFile(join(skill.path, normalized), "utf-8");
+	}
+	/**
+	* Parse YAML frontmatter from SKILL.md
+	*/
+	async parseFrontmatter(skillMdPath) {
+		const match = (await readFile(skillMdPath, "utf-8")).match(/^---\n([\s\S]+?)\n---/);
+		if (!match || !match[1]) throw new Error(`Invalid SKILL.md: missing frontmatter in ${skillMdPath}`);
+		try {
+			return frontmatterSchema.parse(parse(match[1]));
+		} catch (error) {
+			throw new Error(`Invalid frontmatter in ${skillMdPath}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Resolve tilde and relative paths
+	*/
+	resolvePath(path) {
+		if (path.startsWith("~/")) {
+			const home = process.env.HOME || process.env.USERPROFILE;
+			if (!home) throw new Error("Cannot resolve ~/ without HOME environment variable");
+			return join(home, path.slice(2));
+		}
+		return path;
+	}
+	/**
+	* Synchronous version: Add a single skill directory
+	*/
+	addSkillSync(skillPath) {
+		const skillMdPath = join(skillPath, "SKILL.md");
+		try {
+			statSync(skillMdPath);
+		} catch {
+			throw new Error(`SKILL.md not found in ${skillPath}`);
+		}
+		const frontmatter = this.parseFrontmatterSync(skillMdPath);
+		this.skills.set(frontmatter.name, {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			path: skillPath
+		});
+	}
+	/**
+	* Synchronous version: Scan a directory and add all valid skills found
+	*/
+	scanDirectorySync(dir) {
+		const resolved = this.resolvePath(dir);
+		try {
+			const entries = readdirSync(resolved, { withFileTypes: true });
+			for (const entry of entries) if (entry.isDirectory()) {
+				const skillPath = join(resolved, entry.name);
+				try {
+					this.addSkillSync(skillPath);
+				} catch {}
+			}
+		} catch {}
+	}
+	/**
+	* Synchronous version: Parse YAML frontmatter from SKILL.md
+	*/
+	parseFrontmatterSync(skillMdPath) {
+		const match = readFileSync(skillMdPath, "utf-8").match(/^---\n([\s\S]+?)\n---/);
+		if (!match || !match[1]) throw new Error(`Invalid SKILL.md: missing frontmatter in ${skillMdPath}`);
+		try {
+			return frontmatterSchema.parse(parse(match[1]));
+		} catch (error) {
+			throw new Error(`Invalid frontmatter in ${skillMdPath}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Add skills from a SkillImporter (async)
+	* Used for temporary imported skills during session lifecycle
+	*/
+	async addImportedSkills(importer) {
+		const skillPaths = importer.getAllImportedSkillPaths();
+		for (const skillPath of skillPaths) await this.addSkill(skillPath);
+	}
+	/**
+	* Add skills from a SkillImporter (sync)
+	*/
+	addImportedSkillsSync(importer) {
+		const skillPaths = importer.getAllImportedSkillPaths();
+		for (const skillPath of skillPaths) this.addSkillSync(skillPath);
+	}
+};
+
+//#endregion
+//#region src/agent/tools/skills.ts
+/**
+* Create a Skills tool as an AI SDK tool() object
+*/
+function createSkillsTool(provider) {
+	return tool({
+		description: "Interact with available agent skills. Use \"list\" to see all skills with their descriptions, \"view\" to read a complete SKILL.md file, \"readFile\" to read files within a skill directory (e.g., references/, scripts/, assets/).",
+		inputSchema: jsonSchema({
+			type: "object",
+			properties: {
+				operation: {
+					type: "string",
+					enum: [
+						"list",
+						"view",
+						"readFile"
+					],
+					description: "Operation to perform"
+				},
+				skillName: {
+					type: "string",
+					description: "Skill name (required for view and readFile operations)"
+				},
+				filePath: {
+					type: "string",
+					description: "Relative file path within the skill directory (required for readFile operation, e.g., \"references/search-strategies.md\")"
+				}
+			},
+			required: ["operation"]
+		}),
+		execute: async (args) => {
+			const operation = args.operation;
+			const skillName = args.skillName;
+			const filePath = args.filePath;
+			switch (operation) {
+				case "list": {
+					const skills = provider.list();
+					if (skills.length === 0) return { message: "No skills available" };
+					return { skills: skills.map((s) => ({
+						name: s.name,
+						description: s.description
+					})) };
+				}
+				case "view":
+					if (!skillName) throw new Error("skillName is required for view operation");
+					return { content: await provider.view(skillName) };
+				case "readFile":
+					if (!skillName || !filePath) throw new Error("skillName and filePath are required for readFile operation");
+					return { content: await provider.readFile(skillName, filePath) };
+				default: throw new Error(`Unknown operation: ${operation}`);
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/agent/skills/import-spec.ts
+const providerUrls = {
+	github: "https://github.com",
+	gitlab: "https://gitlab.com",
+	gitee: "https://gitee.com"
+};
+/**
+* Parse import spec: [provider:]owner/repo[@ref]:{skill1,skill2,...}
+*
+* Examples:
+*   vercel-labs/agent-skills:react-best-practices
+*   vercel-labs/agent-skills:{react,web}
+*   vercel-labs/agent-skills@v1.0.0:react
+*   github:vercel-labs/agent-skills@main:react
+*   vercel-labs/agent-skills  (imports all)
+*/
+function parseImportSpec(spec) {
+	const match = spec.match(/^(?:([a-z]+):)?([^/@:]+)\/([^/@:]+)(?:@([^:]+))?(?::(.+))?$/);
+	if (!match) throw new Error(`Invalid import spec: ${spec}\nFormat: [provider:]owner/repo[@ref]:{skill1,skill2,...}`);
+	const [, providerMatch = "github", ownerMatch, repoMatch, refMatch = "main", skillsStr] = match;
+	if (!ownerMatch || !repoMatch) throw new Error(`Invalid import spec: ${spec}\nFormat: [provider:]owner/repo[@ref]:{skill1,skill2,...}`);
+	const provider = providerMatch;
+	const owner = ownerMatch;
+	const repo = repoMatch;
+	const ref = refMatch;
+	if (![
+		"github",
+		"gitlab",
+		"gitee"
+	].includes(provider)) throw new Error(`Unsupported provider: ${provider}. Supported: github, gitlab, gitee`);
+	const safeNamePattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+	if (!safeNamePattern.test(owner)) throw new Error(`Invalid owner: "${owner}". Must start with alphanumeric and only contain alphanumeric, hyphen, underscore, or dot`);
+	if (!safeNamePattern.test(repo)) throw new Error(`Invalid repo: "${repo}". Must start with alphanumeric and only contain alphanumeric, hyphen, underscore, or dot`);
+	if (!safeNamePattern.test(ref)) throw new Error(`Invalid ref: "${ref}". Must start with alphanumeric and only contain alphanumeric, hyphen, underscore, or dot`);
+	let skills = "all";
+	if (skillsStr) if (skillsStr.startsWith("{") && skillsStr.endsWith("}")) {
+		const skillList = skillsStr.slice(1, -1).split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+		if (skillList.length === 0) throw new Error("Empty skill list in braces");
+		skills = skillList;
+	} else skills = [skillsStr.trim()];
+	return {
+		provider,
+		owner,
+		repo,
+		ref,
+		skills,
+		rawSpec: spec
+	};
+}
+/**
+* Build Git URL from import spec
+*/
+function buildGitUrl(spec) {
+	return `${providerUrls[spec.provider]}/${spec.owner}/${spec.repo}.git`;
+}
+/**
+* Get display name for import spec
+*/
+function getSpecDisplayName(spec) {
+	const skillsDisplay = spec.skills === "all" ? "all skills" : spec.skills.length === 1 ? spec.skills[0] : `${spec.skills.length} skills`;
+	return `${spec.owner}/${spec.repo}@${spec.ref} (${skillsDisplay})`;
+}
+
+//#endregion
+//#region src/agent/skills/importer.ts
+/**
+* Temporary skill importer for session lifecycle
+* Clones Git repos to temp directory and manages imported skills
+*/
+var SkillImporter = class {
+	tempDir;
+	imported = /* @__PURE__ */ new Map();
+	constructor(sessionId) {
+		this.tempDir = join(tmpdir(), `agent-worker-skills-${sessionId}`);
+	}
+	/**
+	* Import skills from a Git repository
+	*/
+	async import(spec) {
+		const parsed = parseImportSpec(spec);
+		console.log(`Importing: ${getSpecDisplayName(parsed)}`);
+		const repoDir = await this.cloneRepo(parsed);
+		const skillNames = await this.extractSkills(repoDir, parsed);
+		console.log(`✓ Imported ${skillNames.length} skill(s): ${skillNames.join(", ")}`);
+		return skillNames;
+	}
+	/**
+	* Import skills from multiple specs
+	*/
+	async importMultiple(specs) {
+		const allSkillNames = [];
+		for (const spec of specs) try {
+			const skillNames = await this.import(spec);
+			allSkillNames.push(...skillNames);
+		} catch (error) {
+			console.error(`Failed to import ${spec}:`, error);
+		}
+		return allSkillNames;
+	}
+	/**
+	* Get path for an imported skill
+	*/
+	getImportedSkillPath(skillName) {
+		return this.imported.get(skillName)?.tempPath || null;
+	}
+	/**
+	* Get all imported skill paths
+	*/
+	getAllImportedSkillPaths() {
+		return Array.from(this.imported.values()).map((s) => s.tempPath);
+	}
+	/**
+	* Get all imported skills metadata
+	*/
+	getImportedSkills() {
+		return Array.from(this.imported.values());
+	}
+	/**
+	* Get temporary directory path
+	*/
+	getTempDir() {
+		return this.tempDir;
+	}
+	/**
+	* Cleanup temporary directory
+	*/
+	async cleanup() {
+		if (existsSync(this.tempDir)) await rm(this.tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	/**
+	* Clone Git repository (shallow clone)
+	*/
+	async cloneRepo(spec) {
+		await mkdir(this.tempDir, { recursive: true });
+		const repoDir = join(this.tempDir, `${spec.owner}-${spec.repo}`);
+		if (existsSync(repoDir)) return repoDir;
+		const gitUrl = buildGitUrl(spec);
+		await this.execGit([
+			"clone",
+			"--depth",
+			"1",
+			"--branch",
+			spec.ref,
+			"--single-branch",
+			gitUrl,
+			repoDir
+		]);
+		return repoDir;
+	}
+	/**
+	* Extract skills from cloned repository
+	*/
+	async extractSkills(repoDir, spec) {
+		const skillsDir = await this.findSkillsDirectory(repoDir);
+		const skillsToImport = spec.skills === "all" ? await this.findAllSkills(skillsDir) : spec.skills;
+		const importedSkills = [];
+		for (const skillName of skillsToImport) {
+			const skillPath = join(skillsDir, skillName);
+			const skillMdPath = join(skillPath, "SKILL.md");
+			try {
+				await stat(skillMdPath);
+				this.imported.set(skillName, {
+					name: skillName,
+					source: spec.rawSpec,
+					tempPath: skillPath
+				});
+				importedSkills.push(skillName);
+			} catch {
+				console.warn(`Skipping ${skillName}: SKILL.md not found`);
+			}
+		}
+		if (importedSkills.length === 0) throw new Error(`No valid skills found in ${spec.owner}/${spec.repo}`);
+		return importedSkills;
+	}
+	/**
+	* Find skills directory in repository
+	* Tries: skills/, agent-skills/, . (root)
+	*/
+	async findSkillsDirectory(repoDir) {
+		for (const candidate of [
+			"skills",
+			"agent-skills",
+			"."
+		]) {
+			const dir = join(repoDir, candidate);
+			try {
+				if ((await stat(dir)).isDirectory()) {
+					if ((await readdir(dir, { withFileTypes: true })).some((entry) => entry.isDirectory() && existsSync(join(dir, entry.name, "SKILL.md")))) return dir;
+				}
+			} catch {
+				continue;
+			}
+		}
+		throw new Error(`No skills directory found in ${repoDir}`);
+	}
+	/**
+	* Find all skills in a directory
+	*/
+	async findAllSkills(skillsDir) {
+		const entries = await readdir(skillsDir, { withFileTypes: true });
+		const skills = [];
+		for (const entry of entries) if (entry.isDirectory()) {
+			if (existsSync(join(skillsDir, entry.name, "SKILL.md"))) skills.push(entry.name);
+		}
+		return skills;
+	}
+	/**
+	* Execute git command
+	*/
+	async execGit(args) {
+		return new Promise((resolve, reject) => {
+			const git = spawn("git", args, { stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			] });
+			let stdout = "";
+			let stderr = "";
+			git.stdout?.on("data", (data) => {
+				stdout += data.toString();
+			});
+			git.stderr?.on("data", (data) => {
+				stderr += data.toString();
+			});
+			git.on("close", (code) => {
+				if (code === 0) resolve();
+				else reject(/* @__PURE__ */ new Error(`Git command failed (exit ${code}): ${stderr || stdout}`));
+			});
+			git.on("error", (error) => {
+				reject(/* @__PURE__ */ new Error(`Failed to spawn git: ${error.message}`));
+			});
+		});
+	}
+};
+
+//#endregion
+export { AgentWorker as AgentSession, AgentWorker, ClaudeCodeBackend, CodexBackend, CursorBackend, FEEDBACK_PROMPT, FRONTIER_MODELS, MockAIBackend, SUPPORTED_PROVIDERS, SdkBackend, SkillImporter, SkillsProvider, buildGitUrl, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createFeedbackTool, createMockBackend, createModel, createModelAsync, createSkillsTool, getSpecDisplayName, listBackends, parseImportSpec };

package/dist/{logger-C3ekEOzi.mjs → logger-CCFaMMV7.mjs}

@@ -16,7 +16,7 @@ function createSilentLogger() {
 /**
 * Create a logger that writes to the channel.
 *
-* - info/warn/error → channel entry with kind="log" (always shown to user)
+* - info/warn/error → channel entry with kind="system" (always shown to user)
 * - debug → channel entry with kind="debug" (only shown with --debug)
 *
 * The display layer handles formatting and filtering.
@@ -31,7 +31,7 @@ function createChannelLogger(config) {
 	};
 	const write = (level, message, args) => {
 		const content = formatContent(level, message, args);
-		const kind = level === "debug" ? "debug" : "log";
+		const kind = level === "debug" ? "debug" : "system";
 		provider.appendChannel(from, content, { kind }).catch(() => {});
 	};
 	return {

package/dist/memory-provider-CBlKMdbJ.mjs

@@ -0,0 +1,70 @@
+import { o as MemoryStorage, s as ContextProviderImpl } from "./cli/index.mjs";
+
+//#region src/workflow/context/memory-provider.ts
+/**
+* In-memory ContextProvider for testing.
+* All domain logic is inherited from ContextProviderImpl;
+* this class adds test helpers for inspection and cleanup.
+*/
+var MemoryContextProvider = class extends ContextProviderImpl {
+	memoryStorage;
+	constructor(validAgents) {
+		const storage = new MemoryStorage();
+		super(storage, validAgents);
+		this.memoryStorage = storage;
+	}
+	/** Get underlying MemoryStorage (for testing) */
+	getStorage() {
+		return this.memoryStorage;
+	}
+	/** Get all channel messages (for testing, unfiltered) */
+	async getMessages() {
+		return this.readChannel();
+	}
+	/** Clear all data (for testing) */
+	clear() {
+		this.memoryStorage.clear();
+	}
+	/** Get all resources (for testing) */
+	async getResources() {
+		const keys = await this.memoryStorage.list("resources/");
+		const map = /* @__PURE__ */ new Map();
+		for (const key of keys) {
+			const content = await this.memoryStorage.read(`resources/${key}`);
+			if (content !== null) {
+				const id = key.replace(/\.[^.]+$/, "");
+				map.set(id, content);
+			}
+		}
+		return map;
+	}
+	/** Get inbox state for an agent (for testing) */
+	async getInboxState(agent) {
+		const raw = await this.memoryStorage.read("_state/inbox.json");
+		if (!raw) return void 0;
+		try {
+			return JSON.parse(raw).readCursors?.[agent];
+		} catch {
+			return;
+		}
+	}
+	/** Get all documents (for testing) */
+	async getDocuments() {
+		const files = await this.memoryStorage.list("documents/");
+		const map = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const content = await this.memoryStorage.read(`documents/${file}`);
+			if (content !== null) map.set(file, content);
+		}
+		return map;
+	}
+};
+/**
+* Create a memory context provider
+*/
+function createMemoryContextProvider(validAgents) {
+	return new MemoryContextProvider(validAgents);
+}
+
+//#endregion
+export { createMemoryContextProvider as n, MemoryContextProvider as t };