deepagents 1.4.2 → 1.5.0

package/dist/index.js

@@ -5,14 +5,14 @@ import micromatch from "micromatch";
 import { basename } from "path";
 import { z as z$1 } from "zod/v3";
 import { HumanMessage, RemoveMessage } from "@langchain/core/messages";
+import { z as z$2 } from "zod";
+import yaml from "yaml";
 import fs from "node:fs/promises";
 import fs$1 from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import fg from "fast-glob";
 import os from "node:os";
-import { z as z$2 } from "zod";
-import yaml from "yaml";
 
 //#region src/backends/protocol.ts
 /**
@@ -328,23 +328,12 @@ var StateBackend = class {
 	* @param limit - Maximum number of lines to read
 	* @returns Formatted file content with line numbers, or error message
 	*/
-	read(filePath, offset = 0, limit = 2e3) {
+	read(filePath, offset = 0, limit = 500) {
 		const fileData = this.getFiles()[filePath];
 		if (!fileData) return `Error: File '${filePath}' not found`;
 		return formatReadResponse(fileData, offset, limit);
 	}
 	/**
-	* Read file content as raw FileData.
-	*
-	* @param filePath - Absolute file path
-	* @returns Raw file content as FileData
-	*/
-	readRaw(filePath) {
-		const fileData = this.getFiles()[filePath];
-		if (!fileData) throw new Error(`File '${filePath}' not found`);
-		return fileData;
-	}
-	/**
 	* Create a new file with content.
 	* Returns WriteResult with filesUpdate to update LangGraph state.
 	*/
@@ -585,7 +574,7 @@ function createReadFileTool(backend, options) {
 			state: getCurrentTaskInput(config),
 			store: config.store
 		});
-		const { file_path, offset = 0, limit = 2e3 } = input;
+		const { file_path, offset = 0, limit = 500 } = input;
 		return await resolvedBackend.read(file_path, offset, limit);
 	}, {
 		name: "read_file",
@@ -593,7 +582,7 @@ function createReadFileTool(backend, options) {
 		schema: z.object({
 			file_path: z.string().describe("Absolute path to the file to read"),
 			offset: z.coerce.number().optional().default(0).describe("Line offset to start reading from (0-indexed)"),
-			limit: z.coerce.number().optional().default(2e3).describe("Maximum number of lines to read")
+			limit: z.coerce.number().optional().default(500).describe("Maximum number of lines to read")
 		})
 	});
 }
@@ -849,7 +838,7 @@ const DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the use
 const EXCLUDED_STATE_KEYS = [
 	"messages",
 	"todos",
-	"jumpTo",
+	"structuredResponse",
 	"files"
 ];
 const DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
@@ -1164,6 +1153,501 @@ function createPatchToolCallsMiddleware() {
 	});
 }
 
+//#endregion
+//#region src/middleware/memory.ts
+/**
+* Middleware for loading agent memory/context from AGENTS.md files.
+*
+* This module implements support for the AGENTS.md specification (https://agents.md/),
+* loading memory/context from configurable sources and injecting into the system prompt.
+*
+* ## Overview
+*
+* AGENTS.md files provide project-specific context and instructions to help AI agents
+* work effectively. Unlike skills (which are on-demand workflows), memory is always
+* loaded and provides persistent context.
+*
+* ## Usage
+*
+* ```typescript
+* import { createMemoryMiddleware } from "@anthropic/deepagents";
+* import { FilesystemBackend } from "@anthropic/deepagents";
+*
+* // Security: FilesystemBackend allows reading/writing from the entire filesystem.
+* // Either ensure the agent is running within a sandbox OR add human-in-the-loop (HIL)
+* // approval to file operations.
+* const backend = new FilesystemBackend({ rootDir: "/" });
+*
+* const middleware = createMemoryMiddleware({
+*   backend,
+*   sources: [
+*     "~/.deepagents/AGENTS.md",
+*     "./.deepagents/AGENTS.md",
+*   ],
+* });
+*
+* const agent = createDeepAgent({ middleware: [middleware] });
+* ```
+*
+* ## Memory Sources
+*
+* Sources are simply paths to AGENTS.md files that are loaded in order and combined.
+* Multiple sources are concatenated in order, with all content included.
+* Later sources appear after earlier ones in the combined prompt.
+*
+* ## File Format
+*
+* AGENTS.md files are standard Markdown with no required structure.
+* Common sections include:
+* - Project overview
+* - Build/test commands
+* - Code style guidelines
+* - Architecture notes
+*/
+/**
+* State schema for memory middleware.
+*/
+const MemoryStateSchema = z$2.object({ memoryContents: z$2.record(z$2.string(), z$2.string()).optional() });
+/**
+* Default system prompt template for memory.
+* Ported from Python's comprehensive memory guidelines.
+*/
+const MEMORY_SYSTEM_PROMPT = `<agent_memory>
+{memory_contents}
+</agent_memory>
+
+<memory_guidelines>
+    The above <agent_memory> was loaded in from files in your filesystem. As you learn from your interactions with the user, you can save new knowledge by calling the \`edit_file\` tool.
+
+    **Learning from feedback:**
+    - One of your MAIN PRIORITIES is to learn from your interactions with the user. These learnings can be implicit or explicit. This means that in the future, you will remember this important information.
+    - When you need to remember something, updating memory must be your FIRST, IMMEDIATE action - before responding to the user, before calling other tools, before doing anything else. Just update memory immediately.
+    - When user says something is better/worse, capture WHY and encode it as a pattern.
+    - Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions.
+    - A great opportunity to update your memories is when the user interrupts a tool call and provides feedback. You should update your memories immediately before revising the tool call.
+    - Look for the underlying principle behind corrections, not just the specific mistake.
+    - The user might not explicitly ask you to remember something, but if they provide information that is useful for future use, you should update your memories immediately.
+
+    **Asking for information:**
+    - If you lack context to perform an action (e.g. send a Slack DM, requires a user ID/email) you should explicitly ask the user for this information.
+    - It is preferred for you to ask for information, don't assume anything that you do not know!
+    - When the user provides information that is useful for future use, you should update your memories immediately.
+
+    **When to update memories:**
+    - When the user explicitly asks you to remember something (e.g., "remember my email", "save this preference")
+    - When the user describes your role or how you should behave (e.g., "you are a web researcher", "always do X")
+    - When the user gives feedback on your work - capture what was wrong and how to improve
+    - When the user provides information required for tool use (e.g., slack channel ID, email addresses)
+    - When the user provides context useful for future tasks, such as how to use tools, or which actions to take in a particular situation
+    - When you discover new patterns or preferences (coding styles, conventions, workflows)
+
+    **When to NOT update memories:**
+    - When the information is temporary or transient (e.g., "I'm running late", "I'm on my phone right now")
+    - When the information is a one-time task request (e.g., "Find me a recipe", "What's 25 * 4?")
+    - When the information is a simple question that doesn't reveal lasting preferences (e.g., "What day is it?", "Can you explain X?")
+    - When the information is an acknowledgment or small talk (e.g., "Sounds good!", "Hello", "Thanks for that")
+    - When the information is stale or irrelevant in future conversations
+    - Never store API keys, access tokens, passwords, or any other credentials in any file, memory, or system prompt.
+    - If the user asks where to put API keys or provides an API key, do NOT echo or save it.
+
+    **Examples:**
+    Example 1 (remembering user information):
+    User: Can you connect to my google account?
+    Agent: Sure, I'll connect to your google account, what's your google account email?
+    User: john@example.com
+    Agent: Let me save this to my memory.
+    Tool Call: edit_file(...) -> remembers that the user's google account email is john@example.com
+
+    Example 2 (remembering implicit user preferences):
+    User: Can you write me an example for creating a deep agent in LangChain?
+    Agent: Sure, I'll write you an example for creating a deep agent in LangChain <example code in Python>
+    User: Can you do this in JavaScript
+    Agent: Let me save this to my memory.
+    Tool Call: edit_file(...) -> remembers that the user prefers to get LangChain code examples in JavaScript
+    Agent: Sure, here is the JavaScript example<example code in JavaScript>
+
+    Example 3 (do not remember transient information):
+    User: I'm going to play basketball tonight so I will be offline for a few hours.
+    Agent: Okay I'll add a block to your calendar.
+    Tool Call: create_calendar_event(...) -> just calls a tool, does not commit anything to memory, as it is transient information
+</memory_guidelines>`;
+/**
+* Format loaded memory contents for injection into prompt.
+* Pairs memory locations with their contents for clarity.
+*/
+function formatMemoryContents(contents, sources) {
+	if (Object.keys(contents).length === 0) return "(No memory loaded)";
+	const sections = [];
+	for (const path$1 of sources) if (contents[path$1]) sections.push(`${path$1}\n${contents[path$1]}`);
+	if (sections.length === 0) return "(No memory loaded)";
+	return sections.join("\n\n");
+}
+/**
+* Load memory content from a backend path.
+*
+* @param backend - Backend to load from.
+* @param path - Path to the AGENTS.md file.
+* @returns File content if found, null otherwise.
+*/
+async function loadMemoryFromBackend(backend, path$1) {
+	const results = await backend.downloadFiles([path$1]);
+	if (results.length !== 1) throw new Error(`Expected 1 response for path ${path$1}, got ${results.length}`);
+	const response = results[0];
+	if (response.error != null) {
+		if (response.error === "file_not_found") return null;
+		throw new Error(`Failed to download ${path$1}: ${response.error}`);
+	}
+	if (response.content != null) return new TextDecoder().decode(response.content);
+	return null;
+}
+/**
+* Create middleware for loading agent memory from AGENTS.md files.
+*
+* Loads memory content from configured sources and injects into the system prompt.
+* Supports multiple sources that are combined together.
+*
+* @param options - Configuration options
+* @returns AgentMiddleware for memory loading and injection
+*
+* @example
+* ```typescript
+* const middleware = createMemoryMiddleware({
+*   backend: new FilesystemBackend({ rootDir: "/" }),
+*   sources: [
+*     "~/.deepagents/AGENTS.md",
+*     "./.deepagents/AGENTS.md",
+*   ],
+* });
+* ```
+*/
+function createMemoryMiddleware(options) {
+	const { backend, sources } = options;
+	/**
+	* Resolve backend from instance or factory.
+	*/
+	function getBackend$1(state) {
+		if (typeof backend === "function") return backend({ state });
+		return backend;
+	}
+	return createMiddleware({
+		name: "MemoryMiddleware",
+		stateSchema: MemoryStateSchema,
+		async beforeAgent(state) {
+			if ("memoryContents" in state && state.memoryContents != null) return;
+			const resolvedBackend = getBackend$1(state);
+			const contents = {};
+			for (const path$1 of sources) try {
+				const content = await loadMemoryFromBackend(resolvedBackend, path$1);
+				if (content) contents[path$1] = content;
+			} catch (error) {
+				console.debug(`Failed to load memory from ${path$1}:`, error);
+			}
+			return { memoryContents: contents };
+		},
+		wrapModelCall(request, handler) {
+			const formattedContents = formatMemoryContents(request.state?.memoryContents || {}, sources);
+			const memorySection = MEMORY_SYSTEM_PROMPT.replace("{memory_contents}", formattedContents);
+			const currentSystemPrompt = request.systemPrompt || "";
+			const newSystemPrompt = currentSystemPrompt ? `${memorySection}\n\n${currentSystemPrompt}` : memorySection;
+			return handler({
+				...request,
+				systemPrompt: newSystemPrompt
+			});
+		}
+	});
+}
+
+//#endregion
+//#region src/middleware/skills.ts
+/**
+* Backend-agnostic skills middleware for loading agent skills from any backend.
+*
+* This middleware implements Anthropic's agent skills pattern with progressive disclosure,
+* loading skills from backend storage via configurable sources.
+*
+* ## Architecture
+*
+* Skills are loaded from one or more **sources** - paths in a backend where skills are
+* organized. Sources are loaded in order, with later sources overriding earlier ones
+* when skills have the same name (last one wins). This enables layering: base -> user
+* -> project -> team skills.
+*
+* The middleware uses backend APIs exclusively (no direct filesystem access), making it
+* portable across different storage backends (filesystem, state, remote storage, etc.).
+*
+* ## Usage
+*
+* ```typescript
+* import { createSkillsMiddleware, FilesystemBackend } from "@anthropic/deepagents";
+*
+* const middleware = createSkillsMiddleware({
+*   backend: new FilesystemBackend({ rootDir: "/" }),
+*   sources: [
+*     "/skills/user/",
+*     "/skills/project/",
+*   ],
+* });
+*
+* const agent = createDeepAgent({ middleware: [middleware] });
+* ```
+*
+* Or use the `skills` parameter on createDeepAgent:
+*
+* ```typescript
+* const agent = createDeepAgent({
+*   skills: ["/skills/user/", "/skills/project/"],
+* });
+* ```
+*/
+const MAX_SKILL_FILE_SIZE = 10 * 1024 * 1024;
+const MAX_SKILL_NAME_LENGTH = 64;
+const MAX_SKILL_DESCRIPTION_LENGTH = 1024;
+/**
+* State schema for skills middleware.
+*/
+const SkillsStateSchema = z$2.object({ skillsMetadata: z$2.array(z$2.object({
+	name: z$2.string(),
+	description: z$2.string(),
+	path: z$2.string(),
+	license: z$2.string().nullable().optional(),
+	compatibility: z$2.string().nullable().optional(),
+	metadata: z$2.record(z$2.string(), z$2.string()).optional(),
+	allowedTools: z$2.array(z$2.string()).optional()
+})).optional() });
+/**
+* Skills System Documentation prompt template.
+*/
+const SKILLS_SYSTEM_PROMPT = `
+## Skills System
+
+You have access to a skills library that provides specialized capabilities and domain knowledge.
+
+{skills_locations}
+
+**Available Skills:**
+
+{skills_list}
+
+**How to Use Skills (Progressive Disclosure):**
+
+Skills follow a **progressive disclosure** pattern - you know they exist (name + description above), but you only read the full instructions when needed:
+
+1. **Recognize when a skill applies**: Check if the user's task matches any skill's description
+2. **Read the skill's full instructions**: The skill list above shows the exact path to use with read_file
+3. **Follow the skill's instructions**: SKILL.md contains step-by-step workflows, best practices, and examples
+4. **Access supporting files**: Skills may include Python scripts, configs, or reference docs - use absolute paths
+
+**When to Use Skills:**
+- When the user's request matches a skill's domain (e.g., "research X" → web-research skill)
+- When you need specialized knowledge or structured workflows
+- When a skill provides proven patterns for complex tasks
+
+**Skills are Self-Documenting:**
+- Each SKILL.md tells you exactly what the skill does and how to use it
+- The skill list above shows the full path for each skill's SKILL.md file
+
+**Executing Skill Scripts:**
+Skills may contain Python scripts or other executable files. Always use absolute paths from the skill list.
+
+**Example Workflow:**
+
+User: "Can you research the latest developments in quantum computing?"
+
+1. Check available skills above → See "web-research" skill with its full path
+2. Read the skill using the path shown in the list
+3. Follow the skill's research workflow (search → organize → synthesize)
+4. Use any helper scripts with absolute paths
+
+Remember: Skills are tools to make you more capable and consistent. When in doubt, check if a skill exists for the task!
+`;
+/**
+* Validate skill name per Agent Skills specification.
+*/
+function validateSkillName$1(name, directoryName) {
+	if (!name) return {
+		valid: false,
+		error: "name is required"
+	};
+	if (name.length > MAX_SKILL_NAME_LENGTH) return {
+		valid: false,
+		error: "name exceeds 64 characters"
+	};
+	if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) return {
+		valid: false,
+		error: "name must be lowercase alphanumeric with single hyphens only"
+	};
+	if (name !== directoryName) return {
+		valid: false,
+		error: `name '${name}' must match directory name '${directoryName}'`
+	};
+	return {
+		valid: true,
+		error: ""
+	};
+}
+/**
+* Parse YAML frontmatter from SKILL.md content.
+*/
+function parseSkillMetadataFromContent(content, skillPath, directoryName) {
+	if (content.length > MAX_SKILL_FILE_SIZE) {
+		console.warn(`Skipping ${skillPath}: content too large (${content.length} bytes)`);
+		return null;
+	}
+	const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+	if (!match) {
+		console.warn(`Skipping ${skillPath}: no valid YAML frontmatter found`);
+		return null;
+	}
+	const frontmatterStr = match[1];
+	let frontmatterData;
+	try {
+		frontmatterData = yaml.parse(frontmatterStr);
+	} catch (e) {
+		console.warn(`Invalid YAML in ${skillPath}:`, e);
+		return null;
+	}
+	if (!frontmatterData || typeof frontmatterData !== "object") {
+		console.warn(`Skipping ${skillPath}: frontmatter is not a mapping`);
+		return null;
+	}
+	const name = frontmatterData.name;
+	const description = frontmatterData.description;
+	if (!name || !description) {
+		console.warn(`Skipping ${skillPath}: missing required 'name' or 'description'`);
+		return null;
+	}
+	const validation = validateSkillName$1(String(name), directoryName);
+	if (!validation.valid) console.warn(`Skill '${name}' in ${skillPath} does not follow Agent Skills specification: ${validation.error}. Consider renaming for spec compliance.`);
+	let descriptionStr = String(description).trim();
+	if (descriptionStr.length > MAX_SKILL_DESCRIPTION_LENGTH) {
+		console.warn(`Description exceeds ${MAX_SKILL_DESCRIPTION_LENGTH} characters in ${skillPath}, truncating`);
+		descriptionStr = descriptionStr.slice(0, MAX_SKILL_DESCRIPTION_LENGTH);
+	}
+	const allowedToolsStr = frontmatterData["allowed-tools"];
+	const allowedTools = allowedToolsStr ? allowedToolsStr.split(" ") : [];
+	return {
+		name: String(name),
+		description: descriptionStr,
+		path: skillPath,
+		metadata: frontmatterData.metadata || {},
+		license: typeof frontmatterData.license === "string" ? frontmatterData.license.trim() || null : null,
+		compatibility: typeof frontmatterData.compatibility === "string" ? frontmatterData.compatibility.trim() || null : null,
+		allowedTools
+	};
+}
+/**
+* List all skills from a backend source.
+*/
+async function listSkillsFromBackend(backend, sourcePath) {
+	const skills = [];
+	const normalizedPath = sourcePath.endsWith("/") ? sourcePath : `${sourcePath}/`;
+	let fileInfos;
+	try {
+		fileInfos = await backend.lsInfo(normalizedPath);
+	} catch {
+		return [];
+	}
+	const entries = fileInfos.map((info) => ({
+		name: info.path.replace(/\/$/, "").split("/").pop() || "",
+		type: info.is_dir ? "directory" : "file"
+	}));
+	for (const entry of entries) {
+		if (entry.type !== "directory") continue;
+		const skillMdPath = `${normalizedPath}${entry.name}/SKILL.md`;
+		const results = await backend.downloadFiles([skillMdPath]);
+		if (results.length !== 1) continue;
+		const response = results[0];
+		if (response.error != null || response.content == null) continue;
+		const metadata = parseSkillMetadataFromContent(new TextDecoder().decode(response.content), skillMdPath, entry.name);
+		if (metadata) skills.push(metadata);
+	}
+	return skills;
+}
+/**
+* Format skills locations for display in system prompt.
+*/
+function formatSkillsLocations(sources) {
+	if (sources.length === 0) return "**Skills Sources:** None configured";
+	const lines = ["**Skills Sources:**"];
+	for (const source of sources) lines.push(`- \`${source}\``);
+	return lines.join("\n");
+}
+/**
+* Format skills metadata for display in system prompt.
+*/
+function formatSkillsList(skills, sources) {
+	if (skills.length === 0) return `(No skills available yet. Skills can be created in ${sources.join(" or ")})`;
+	const lines = [];
+	for (const skill of skills) {
+		lines.push(`- **${skill.name}**: ${skill.description}`);
+		lines.push(`  → Read \`${skill.path}\` for full instructions`);
+	}
+	return lines.join("\n");
+}
+/**
+* Create backend-agnostic middleware for loading and exposing agent skills.
+*
+* This middleware loads skills from configurable backend sources and injects
+* skill metadata into the system prompt. It implements the progressive disclosure
+* pattern: skill names and descriptions are shown in the prompt, but the agent
+* reads full SKILL.md content only when needed.
+*
+* @param options - Configuration options
+* @returns AgentMiddleware for skills loading and injection
+*
+* @example
+* ```typescript
+* const middleware = createSkillsMiddleware({
+*   backend: new FilesystemBackend({ rootDir: "/" }),
+*   sources: ["/skills/user/", "/skills/project/"],
+* });
+* ```
+*/
+function createSkillsMiddleware(options) {
+	const { backend, sources } = options;
+	let loadedSkills = [];
+	/**
+	* Resolve backend from instance or factory.
+	*/
+	function getBackend$1(state) {
+		if (typeof backend === "function") return backend({ state });
+		return backend;
+	}
+	return createMiddleware({
+		name: "SkillsMiddleware",
+		stateSchema: SkillsStateSchema,
+		async beforeAgent(state) {
+			if (loadedSkills.length > 0) return;
+			if ("skillsMetadata" in state && state.skillsMetadata != null) {
+				loadedSkills = state.skillsMetadata;
+				return;
+			}
+			const resolvedBackend = getBackend$1(state);
+			const allSkills = /* @__PURE__ */ new Map();
+			for (const sourcePath of sources) try {
+				const skills = await listSkillsFromBackend(resolvedBackend, sourcePath);
+				for (const skill of skills) allSkills.set(skill.name, skill);
+			} catch (error) {
+				console.debug(`[BackendSkillsMiddleware] Failed to load skills from ${sourcePath}:`, error);
+			}
+			loadedSkills = Array.from(allSkills.values());
+			return { skillsMetadata: loadedSkills };
+		},
+		wrapModelCall(request, handler) {
+			const skillsMetadata = loadedSkills.length > 0 ? loadedSkills : request.state?.skillsMetadata || [];
+			const skillsLocations = formatSkillsLocations(sources);
+			const skillsList = formatSkillsList(skillsMetadata, sources);
+			const skillsSection = SKILLS_SYSTEM_PROMPT.replace("{skills_locations}", skillsLocations).replace("{skills_list}", skillsList);
+			const currentSystemPrompt = request.systemPrompt || "";
+			const newSystemPrompt = currentSystemPrompt ? `${currentSystemPrompt}\n\n${skillsSection}` : skillsSection;
+			return handler({
+				...request,
+				systemPrompt: newSystemPrompt
+			});
+		}
+	});
+}
+
 //#endregion
 //#region src/backends/store.ts
 /**
@@ -1311,27 +1795,18 @@ var StoreBackend = class {
 	* @param limit - Maximum number of lines to read
 	* @returns Formatted file content with line numbers, or error message
 	*/
-	async read(filePath, offset = 0, limit = 2e3) {
+	async read(filePath, offset = 0, limit = 500) {
 		try {
-			return formatReadResponse(await this.readRaw(filePath), offset, limit);
+			const store = this.getStore();
+			const namespace = this.getNamespace();
+			const item = await store.get(namespace, filePath);
+			if (!item) return `Error: File '${filePath}' not found`;
+			return formatReadResponse(this.convertStoreItemToFileData(item), offset, limit);
 		} catch (e) {
 			return `Error: ${e.message}`;
 		}
 	}
 	/**
-	* Read file content as raw FileData.
-	*
-	* @param filePath - Absolute file path
-	* @returns Raw file content as FileData
-	*/
-	async readRaw(filePath) {
-		const store = this.getStore();
-		const namespace = this.getNamespace();
-		const item = await store.get(namespace, filePath);
-		if (!item) throw new Error(`File '${filePath}' not found`);
-		return this.convertStoreItemToFileData(item);
-	}
-	/**
 	* Create a new file with content.
 	* Returns WriteResult. External storage sets filesUpdate=null.
 	*/
@@ -1605,7 +2080,7 @@ var FilesystemBackend = class {
 	* @param limit - Maximum number of lines to read
 	* @returns Formatted file content with line numbers, or error message
 	*/
-	async read(filePath, offset = 0, limit = 2e3) {
+	async read(filePath, offset = 0, limit = 500) {
 		try {
 			const resolvedPath = this.resolvePath(filePath);
 			let content;
@@ -1635,37 +2110,6 @@ var FilesystemBackend = class {
 		}
 	}
 	/**
-	* Read file content as raw FileData.
-	*
-	* @param filePath - Absolute file path
-	* @returns Raw file content as FileData
-	*/
-	async readRaw(filePath) {
-		const resolvedPath = this.resolvePath(filePath);
-		let content;
-		let stat;
-		if (SUPPORTS_NOFOLLOW) {
-			stat = await fs.stat(resolvedPath);
-			if (!stat.isFile()) throw new Error(`File '${filePath}' not found`);
-			const fd = await fs.open(resolvedPath, fs$1.constants.O_RDONLY | fs$1.constants.O_NOFOLLOW);
-			try {
-				content = await fd.readFile({ encoding: "utf-8" });
-			} finally {
-				await fd.close();
-			}
-		} else {
-			stat = await fs.lstat(resolvedPath);
-			if (stat.isSymbolicLink()) throw new Error(`Symlinks are not allowed: ${filePath}`);
-			if (!stat.isFile()) throw new Error(`File '${filePath}' not found`);
-			content = await fs.readFile(resolvedPath, "utf-8");
-		}
-		return {
-			content: content.split("\n"),
-			created_at: stat.ctime.toISOString(),
-			modified_at: stat.mtime.toISOString()
-		};
-	}
-	/**
 	* Create a new file with content.
 	* Returns WriteResult. External storage sets filesUpdate=null.
 	*/
@@ -2068,21 +2512,11 @@ var CompositeBackend = class {
 	* @param limit - Maximum number of lines to read
 	* @returns Formatted file content with line numbers, or error message
 	*/
-	async read(filePath, offset = 0, limit = 2e3) {
+	async read(filePath, offset = 0, limit = 500) {
 		const [backend, strippedKey] = this.getBackendAndKey(filePath);
 		return await backend.read(strippedKey, offset, limit);
 	}
 	/**
-	* Read file content as raw FileData.
-	*
-	* @param filePath - Absolute file path
-	* @returns Raw file content as FileData
-	*/
-	async readRaw(filePath) {
-		const [backend, strippedKey] = this.getBackendAndKey(filePath);
-		return await backend.readRaw(strippedKey);
-	}
-	/**
 	* Structured search results or error string for invalid input.
 	*/
 	async grepRaw(pattern, path$1 = "/", glob = null) {
@@ -2519,42 +2953,20 @@ var BaseSandbox = class {
 	* @param limit - Maximum number of lines to read
 	* @returns Formatted file content with line numbers, or error message
 	*/
-	async read(filePath, offset = 0, limit = 2e3) {
+	async read(filePath, offset = 0, limit = 500) {
 		const command = buildReadCommand(filePath, offset, limit);
 		const result = await this.execute(command);
 		if (result.exitCode !== 0) return `Error: File '${filePath}' not found`;
 		return result.output;
 	}
 	/**
-	* Read file content as raw FileData.
-	*
-	* @param filePath - Absolute file path
-	* @returns Raw file content as FileData
+	* Structured search results or error string for invalid input.
 	*/
-	async readRaw(filePath) {
-		const command = buildReadCommand(filePath, 0, Number.MAX_SAFE_INTEGER);
+	async grepRaw(pattern, path$1 = "/", glob = null) {
+		const command = buildGrepCommand(pattern, path$1, glob);
 		const result = await this.execute(command);
-		if (result.exitCode !== 0) throw new Error(`File '${filePath}' not found`);
-		const lines = [];
-		for (const line of result.output.split("\n")) {
-			const tabIndex = line.indexOf("	");
-			if (tabIndex !== -1) lines.push(line.substring(tabIndex + 1));
-		}
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		return {
-			content: lines,
-			created_at: now,
-			modified_at: now
-		};
-	}
-	/**
-	* Structured search results or error string for invalid input.
-	*/
-	async grepRaw(pattern, path$1 = "/", glob = null) {
-		const command = buildGrepCommand(pattern, path$1, glob);
-		const result = await this.execute(command);
-		if (result.exitCode === 1) {
-			if (result.output.includes("Invalid regex:")) return result.output.trim();
+		if (result.exitCode === 1) {
+			if (result.output.includes("Invalid regex:")) return result.output.trim();
 		}
 		const matches = [];
 		const lines = result.output.trim().split("\n").filter(Boolean);
@@ -2653,7 +3065,7 @@ const BASE_PROMPT = `In order to complete the objective that the user asks of yo
 * ```
 */
 function createDeepAgent(params = {}) {
-	const { model = "claude-sonnet-4-5-20250929", tools = [], systemPrompt, middleware: customMiddleware = [], subagents = [], responseFormat, contextSchema, checkpointer, store, backend, interruptOn, name } = params;
+	const { model = "claude-sonnet-4-5-20250929", tools = [], systemPrompt, middleware: customMiddleware = [], subagents = [], responseFormat, contextSchema, checkpointer, store, backend, interruptOn, name, memory, skills } = params;
 	const finalSystemPrompt = systemPrompt ? typeof systemPrompt === "string" ? `${systemPrompt}\n\n${BASE_PROMPT}` : new SystemMessage({ content: [{
 		type: "text",
 		text: BASE_PROMPT
@@ -2662,14 +3074,20 @@ function createDeepAgent(params = {}) {
 		text: systemPrompt.content
 	}] : systemPrompt.content] }) : BASE_PROMPT;
 	const filesystemBackend = backend ? backend : (config) => new StateBackend(config);
+	const skillsMiddleware = skills != null && skills.length > 0 ? [createSkillsMiddleware({
+		backend: filesystemBackend,
+		sources: skills
+	})] : [];
 	const builtInMiddleware = [
 		todoListMiddleware(),
+		...skillsMiddleware,
 		createFilesystemMiddleware({ backend: filesystemBackend }),
 		createSubAgentMiddleware({
 			defaultModel: model,
 			defaultTools: tools,
 			defaultMiddleware: [
 				todoListMiddleware(),
+				...skillsMiddleware,
 				createFilesystemMiddleware({ backend: filesystemBackend }),
 				summarizationMiddleware({
 					model,
@@ -2689,7 +3107,11 @@ function createDeepAgent(params = {}) {
 			keep: { messages: 6 }
 		}),
 		anthropicPromptCachingMiddleware({ unsupportedModelBehavior: "ignore" }),
-		createPatchToolCallsMiddleware()
+		createPatchToolCallsMiddleware(),
+		...memory != null && memory.length > 0 ? [createMemoryMiddleware({
+			backend: filesystemBackend,
+			sources: memory
+		})] : []
 	];
 	if (interruptOn) builtInMiddleware.push(humanInTheLoopMiddleware({ interruptOn }));
 	return createAgent({
@@ -2799,6 +3221,206 @@ function createSettings(options = {}) {
 	};
 }
 
+//#endregion
+//#region src/middleware/agent-memory.ts
+/**
+* Middleware for loading agent-specific long-term memory into the system prompt.
+*
+* This middleware loads the agent's long-term memory from agent.md files
+* and injects it into the system prompt. Memory is loaded from:
+* - User memory: ~/.deepagents/{agent_name}/agent.md
+* - Project memory: {project_root}/.deepagents/agent.md
+*/
+/**
+* State schema for agent memory middleware.
+*/
+const AgentMemoryStateSchema = z$2.object({
+	userMemory: z$2.string().optional(),
+	projectMemory: z$2.string().optional()
+});
+/**
+* Default template for memory injection.
+*/
+const DEFAULT_MEMORY_TEMPLATE = `<user_memory>
+{user_memory}
+</user_memory>
+
+<project_memory>
+{project_memory}
+</project_memory>`;
+/**
+* Long-term Memory Documentation system prompt.
+*/
+const LONGTERM_MEMORY_SYSTEM_PROMPT = `
+
+## Long-term Memory
+
+Your long-term memory is stored in files on the filesystem and persists across sessions.
+
+**User Memory Location**: \`{agent_dir_absolute}\` (displays as \`{agent_dir_display}\`)
+**Project Memory Location**: {project_memory_info}
+
+Your system prompt is loaded from TWO sources at startup:
+1. **User agent.md**: \`{agent_dir_absolute}/agent.md\` - Your personal preferences across all projects
+2. **Project agent.md**: Loaded from project root if available - Project-specific instructions
+
+Project-specific agent.md is loaded from these locations (both combined if both exist):
+- \`[project-root]/.deepagents/agent.md\` (preferred)
+- \`[project-root]/agent.md\` (fallback, but also included if both exist)
+
+**When to CHECK/READ memories (CRITICAL - do this FIRST):**
+- **At the start of ANY new session**: Check both user and project memories
+  - User: \`ls {agent_dir_absolute}\`
+  - Project: \`ls {project_deepagents_dir}\` (if in a project)
+- **BEFORE answering questions**: If asked "what do you know about X?" or "how do I do Y?", check project memories FIRST, then user
+- **When user asks you to do something**: Check if you have project-specific guides or examples
+- **When user references past work**: Search project memory files for related context
+
+**Memory-first response pattern:**
+1. User asks a question → Check project directory first: \`ls {project_deepagents_dir}\`
+2. If relevant files exist → Read them with \`read_file '{project_deepagents_dir}/[filename]'\`
+3. Check user memory if needed → \`ls {agent_dir_absolute}\`
+4. Base your answer on saved knowledge supplemented by general knowledge
+
+**When to update memories:**
+- **IMMEDIATELY when the user describes your role or how you should behave**
+- **IMMEDIATELY when the user gives feedback on your work** - Update memories to capture what was wrong and how to do it better
+- When the user explicitly asks you to remember something
+- When patterns or preferences emerge (coding styles, conventions, workflows)
+- After significant work where context would help in future sessions
+
+**Learning from feedback:**
+- When user says something is better/worse, capture WHY and encode it as a pattern
+- Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions
+- When user says "you should remember X" or "be careful about Y", treat this as HIGH PRIORITY - update memories IMMEDIATELY
+- Look for the underlying principle behind corrections, not just the specific mistake
+
+## Deciding Where to Store Memory
+
+When writing or updating agent memory, decide whether each fact, configuration, or behavior belongs in:
+
+### User Agent File: \`{agent_dir_absolute}/agent.md\`
+→ Describes the agent's **personality, style, and universal behavior** across all projects.
+
+**Store here:**
+- Your general tone and communication style
+- Universal coding preferences (formatting, comment style, etc.)
+- General workflows and methodologies you follow
+- Tool usage patterns that apply everywhere
+- Personal preferences that don't change per-project
+
+**Examples:**
+- "Be concise and direct in responses"
+- "Always use type hints in Python"
+- "Prefer functional programming patterns"
+
+### Project Agent File: \`{project_deepagents_dir}/agent.md\`
+→ Describes **how this specific project works** and **how the agent should behave here only.**
+
+**Store here:**
+- Project-specific architecture and design patterns
+- Coding conventions specific to this codebase
+- Project structure and organization
+- Testing strategies for this project
+- Deployment processes and workflows
+- Team conventions and guidelines
+
+**Examples:**
+- "This project uses FastAPI with SQLAlchemy"
+- "Tests go in tests/ directory mirroring src/ structure"
+- "All API changes require updating OpenAPI spec"
+
+### Project Memory Files: \`{project_deepagents_dir}/*.md\`
+→ Use for **project-specific reference information** and structured notes.
+
+**Store here:**
+- API design documentation
+- Architecture decisions and rationale
+- Deployment procedures
+- Common debugging patterns
+- Onboarding information
+
+**Examples:**
+- \`{project_deepagents_dir}/api-design.md\` - REST API patterns used
+- \`{project_deepagents_dir}/architecture.md\` - System architecture overview
+- \`{project_deepagents_dir}/deployment.md\` - How to deploy this project
+
+### File Operations:
+
+**User memory:**
+\`\`\`
+ls {agent_dir_absolute}                              # List user memory files
+read_file '{agent_dir_absolute}/agent.md'            # Read user preferences
+edit_file '{agent_dir_absolute}/agent.md' ...        # Update user preferences
+\`\`\`
+
+**Project memory (preferred for project-specific information):**
+\`\`\`
+ls {project_deepagents_dir}                          # List project memory files
+read_file '{project_deepagents_dir}/agent.md'        # Read project instructions
+edit_file '{project_deepagents_dir}/agent.md' ...    # Update project instructions
+write_file '{project_deepagents_dir}/agent.md' ...  # Create project memory file
+\`\`\`
+
+**Important**:
+- Project memory files are stored in \`.deepagents/\` inside the project root
+- Always use absolute paths for file operations
+- Check project memories BEFORE user when answering project-specific questions`;
+/**
+* Create middleware for loading agent-specific long-term memory.
+*
+* This middleware loads the agent's long-term memory from a file (agent.md)
+* and injects it into the system prompt. The memory is loaded once at the
+* start of the conversation and stored in state.
+*
+* @param options - Configuration options
+* @returns AgentMiddleware for memory loading and injection
+*/
+function createAgentMemoryMiddleware(options) {
+	const { settings, assistantId, systemPromptTemplate } = options;
+	const agentDir = settings.getAgentDir(assistantId);
+	const agentDirDisplay = `~/.deepagents/${assistantId}`;
+	const agentDirAbsolute = agentDir;
+	const projectRoot = settings.projectRoot;
+	const projectMemoryInfo = projectRoot ? `\`${projectRoot}\` (detected)` : "None (not in a git project)";
+	const projectDeepagentsDir = projectRoot ? `${projectRoot}/.deepagents` : "[project-root]/.deepagents (not in a project)";
+	const template = systemPromptTemplate || DEFAULT_MEMORY_TEMPLATE;
+	return createMiddleware({
+		name: "AgentMemoryMiddleware",
+		stateSchema: AgentMemoryStateSchema,
+		beforeAgent(state) {
+			const result = {};
+			if (!("userMemory" in state)) {
+				const userPath = settings.getUserAgentMdPath(assistantId);
+				if (fs$1.existsSync(userPath)) try {
+					result.userMemory = fs$1.readFileSync(userPath, "utf-8");
+				} catch {}
+			}
+			if (!("projectMemory" in state)) {
+				const projectPath = settings.getProjectAgentMdPath();
+				if (projectPath && fs$1.existsSync(projectPath)) try {
+					result.projectMemory = fs$1.readFileSync(projectPath, "utf-8");
+				} catch {}
+			}
+			return Object.keys(result).length > 0 ? result : void 0;
+		},
+		wrapModelCall(request, handler) {
+			const userMemory = request.state?.userMemory;
+			const projectMemory = request.state?.projectMemory;
+			const baseSystemPrompt = request.systemPrompt || "";
+			const memorySection = template.replace("{user_memory}", userMemory || "(No user agent.md)").replace("{project_memory}", projectMemory || "(No project agent.md)");
+			const memoryDocs = LONGTERM_MEMORY_SYSTEM_PROMPT.replaceAll("{agent_dir_absolute}", agentDirAbsolute).replaceAll("{agent_dir_display}", agentDirDisplay).replaceAll("{project_memory_info}", projectMemoryInfo).replaceAll("{project_deepagents_dir}", projectDeepagentsDir);
+			let systemPrompt = memorySection;
+			if (baseSystemPrompt) systemPrompt += "\n\n" + baseSystemPrompt;
+			systemPrompt += "\n\n" + memoryDocs;
+			return handler({
+				...request,
+				systemPrompt
+			});
+		}
+	});
+}
+
 //#endregion
 //#region src/skills/loader.ts
 /**
@@ -2827,10 +3449,10 @@ function createSettings(options = {}) {
 * @see https://agentskills.io/specification
 */
 /** Maximum size for SKILL.md files (10MB) */
-const MAX_SKILL_FILE_SIZE = 10 * 1024 * 1024;
+const MAX_SKILL_FILE_SIZE$1 = 10 * 1024 * 1024;
 /** Agent Skills spec constraints */
-const MAX_SKILL_NAME_LENGTH = 64;
-const MAX_SKILL_DESCRIPTION_LENGTH = 1024;
+const MAX_SKILL_NAME_LENGTH$1 = 64;
+const MAX_SKILL_DESCRIPTION_LENGTH$1 = 1024;
 /** Pattern for validating skill names per Agent Skills spec */
 const SKILL_NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 /** Pattern for extracting YAML frontmatter */
@@ -2874,7 +3496,7 @@ function validateSkillName(name, directoryName) {
 		valid: false,
 		error: "name is required"
 	};
-	if (name.length > MAX_SKILL_NAME_LENGTH) return {
+	if (name.length > MAX_SKILL_NAME_LENGTH$1) return {
 		valid: false,
 		error: "name exceeds 64 characters"
 	};
@@ -2914,7 +3536,7 @@ function parseFrontmatter(content) {
 function parseSkillMetadata(skillMdPath, source) {
 	try {
 		const stats = fs$1.statSync(skillMdPath);
-		if (stats.size > MAX_SKILL_FILE_SIZE) {
+		if (stats.size > MAX_SKILL_FILE_SIZE$1) {
 			console.warn(`Skipping ${skillMdPath}: file too large (${stats.size} bytes)`);
 			return null;
 		}
@@ -2933,9 +3555,9 @@ function parseSkillMetadata(skillMdPath, source) {
 		const validation = validateSkillName(String(name), directoryName);
 		if (!validation.valid) console.warn(`Skill '${name}' in ${skillMdPath} does not follow Agent Skills spec: ${validation.error}. Consider renaming to be spec-compliant.`);
 		let descriptionStr = String(description);
-		if (descriptionStr.length > MAX_SKILL_DESCRIPTION_LENGTH) {
-			console.warn(`Description exceeds ${MAX_SKILL_DESCRIPTION_LENGTH} chars in ${skillMdPath}, truncating`);
-			descriptionStr = descriptionStr.slice(0, MAX_SKILL_DESCRIPTION_LENGTH);
+		if (descriptionStr.length > MAX_SKILL_DESCRIPTION_LENGTH$1) {
+			console.warn(`Description exceeds ${MAX_SKILL_DESCRIPTION_LENGTH$1} chars in ${skillMdPath}, truncating`);
+			descriptionStr = descriptionStr.slice(0, MAX_SKILL_DESCRIPTION_LENGTH$1);
 		}
 		return {
 			name: String(name),
@@ -3023,374 +3645,5 @@ function listSkills(options) {
 }
 
 //#endregion
-//#region src/middleware/skills.ts
-/**
-* Middleware for loading and exposing agent skills to the system prompt.
-*
-* This middleware implements Anthropic's "Agent Skills" pattern with progressive disclosure:
-* 1. Parse YAML frontmatter from SKILL.md files at session start
-* 2. Inject skills metadata (name + description) into system prompt
-* 3. Agent reads full SKILL.md content when relevant to a task
-*
-* Skills directory structure (per-agent + project):
-* User-level: ~/.deepagents/{AGENT_NAME}/skills/
-* Project-level: {PROJECT_ROOT}/.deepagents/skills/
-*
-* @example
-* ```
-* ~/.deepagents/{AGENT_NAME}/skills/
-* ├── web-research/
-* │   ├── SKILL.md        # Required: YAML frontmatter + instructions
-* │   └── helper.py       # Optional: supporting files
-* ├── code-review/
-* │   ├── SKILL.md
-* │   └── checklist.md
-*
-* .deepagents/skills/
-* ├── project-specific/
-* │   └── SKILL.md        # Project-specific skills
-* ```
-*/
-/**
-* State schema for skills middleware.
-*/
-const SkillsStateSchema = z$2.object({ skillsMetadata: z$2.array(z$2.object({
-	name: z$2.string(),
-	description: z$2.string(),
-	path: z$2.string(),
-	source: z$2.enum(["user", "project"]),
-	license: z$2.string().optional(),
-	compatibility: z$2.string().optional(),
-	metadata: z$2.record(z$2.string(), z$2.string()).optional(),
-	allowedTools: z$2.string().optional()
-})).optional() });
-/**
-* Skills System Documentation prompt template.
-*/
-const SKILLS_SYSTEM_PROMPT = `
-
-## Skills System
-
-You have access to a skills library that provides specialized capabilities and domain knowledge.
-
-{skills_locations}
-
-**Available Skills:**
-
-{skills_list}
-
-**How to Use Skills (Progressive Disclosure):**
-
-Skills follow a **progressive disclosure** pattern - you know they exist (name + description above), but you only read the full instructions when needed:
-
-1. **Recognize when a skill applies**: Check if the user's task matches any skill's description
-2. **Read the skill's full instructions**: The skill list above shows the exact path to use with read_file
-3. **Follow the skill's instructions**: SKILL.md contains step-by-step workflows, best practices, and examples
-4. **Access supporting files**: Skills may include Python scripts, configs, or reference docs - use absolute paths
-
-**When to Use Skills:**
-- When the user's request matches a skill's domain (e.g., "research X" → web-research skill)
-- When you need specialized knowledge or structured workflows
-- When a skill provides proven patterns for complex tasks
-
-**Skills are Self-Documenting:**
-- Each SKILL.md tells you exactly what the skill does and how to use it
-- The skill list above shows the full path for each skill's SKILL.md file
-
-**Executing Skill Scripts:**
-Skills may contain Python scripts or other executable files. Always use absolute paths from the skill list.
-
-**Example Workflow:**
-
-User: "Can you research the latest developments in quantum computing?"
-
-1. Check available skills above → See "web-research" skill with its full path
-2. Read the skill using the path shown in the list
-3. Follow the skill's research workflow (search → organize → synthesize)
-4. Use any helper scripts with absolute paths
-
-Remember: Skills are tools to make you more capable and consistent. When in doubt, check if a skill exists for the task!
-`;
-/**
-* Format skills locations for display in system prompt.
-*/
-function formatSkillsLocations(userSkillsDisplay, projectSkillsDir) {
-	const locations = [`**User Skills**: \`${userSkillsDisplay}\``];
-	if (projectSkillsDir) locations.push(`**Project Skills**: \`${projectSkillsDir}\` (overrides user skills)`);
-	return locations.join("\n");
-}
-/**
-* Format skills metadata for display in system prompt.
-*/
-function formatSkillsList(skills, userSkillsDisplay, projectSkillsDir) {
-	if (skills.length === 0) {
-		const locations = [userSkillsDisplay];
-		if (projectSkillsDir) locations.push(projectSkillsDir);
-		return `(No skills available yet. You can create skills in ${locations.join(" or ")})`;
-	}
-	const userSkills = skills.filter((s) => s.source === "user");
-	const projectSkills = skills.filter((s) => s.source === "project");
-	const lines = [];
-	if (userSkills.length > 0) {
-		lines.push("**User Skills:**");
-		for (const skill of userSkills) {
-			lines.push(`- **${skill.name}**: ${skill.description}`);
-			lines.push(`  → Read \`${skill.path}\` for full instructions`);
-		}
-		lines.push("");
-	}
-	if (projectSkills.length > 0) {
-		lines.push("**Project Skills:**");
-		for (const skill of projectSkills) {
-			lines.push(`- **${skill.name}**: ${skill.description}`);
-			lines.push(`  → Read \`${skill.path}\` for full instructions`);
-		}
-	}
-	return lines.join("\n");
-}
-/**
-* Create middleware for loading and exposing agent skills.
-*
-* This middleware implements Anthropic's agent skills pattern:
-* - Loads skills metadata (name, description) from YAML frontmatter at session start
-* - Injects skills list into system prompt for discoverability
-* - Agent reads full SKILL.md content when a skill is relevant (progressive disclosure)
-*
-* Supports both user-level and project-level skills:
-* - User skills: ~/.deepagents/{AGENT_NAME}/skills/
-* - Project skills: {PROJECT_ROOT}/.deepagents/skills/
-* - Project skills override user skills with the same name
-*
-* @param options - Configuration options
-* @returns AgentMiddleware for skills loading and injection
-*/
-function createSkillsMiddleware(options) {
-	const { skillsDir, assistantId, projectSkillsDir } = options;
-	const userSkillsDisplay = `~/.deepagents/${assistantId}/skills`;
-	return createMiddleware({
-		name: "SkillsMiddleware",
-		stateSchema: SkillsStateSchema,
-		beforeAgent() {
-			return { skillsMetadata: listSkills({
-				userSkillsDir: skillsDir,
-				projectSkillsDir
-			}) };
-		},
-		wrapModelCall(request, handler) {
-			const skillsMetadata = request.state?.skillsMetadata || [];
-			const skillsLocations = formatSkillsLocations(userSkillsDisplay, projectSkillsDir);
-			const skillsList = formatSkillsList(skillsMetadata, userSkillsDisplay, projectSkillsDir);
-			const skillsSection = SKILLS_SYSTEM_PROMPT.replace("{skills_locations}", skillsLocations).replace("{skills_list}", skillsList);
-			const currentSystemPrompt = request.systemPrompt || "";
-			const newSystemPrompt = currentSystemPrompt ? `${currentSystemPrompt}\n\n${skillsSection}` : skillsSection;
-			return handler({
-				...request,
-				systemPrompt: newSystemPrompt
-			});
-		}
-	});
-}
-
-//#endregion
-//#region src/middleware/agent-memory.ts
-/**
-* Middleware for loading agent-specific long-term memory into the system prompt.
-*
-* This middleware loads the agent's long-term memory from agent.md files
-* and injects it into the system prompt. Memory is loaded from:
-* - User memory: ~/.deepagents/{agent_name}/agent.md
-* - Project memory: {project_root}/.deepagents/agent.md
-*/
-/**
-* State schema for agent memory middleware.
-*/
-const AgentMemoryStateSchema = z$2.object({
-	userMemory: z$2.string().optional(),
-	projectMemory: z$2.string().optional()
-});
-/**
-* Default template for memory injection.
-*/
-const DEFAULT_MEMORY_TEMPLATE = `<user_memory>
-{user_memory}
-</user_memory>
-
-<project_memory>
-{project_memory}
-</project_memory>`;
-/**
-* Long-term Memory Documentation system prompt.
-*/
-const LONGTERM_MEMORY_SYSTEM_PROMPT = `
-
-## Long-term Memory
-
-Your long-term memory is stored in files on the filesystem and persists across sessions.
-
-**User Memory Location**: \`{agent_dir_absolute}\` (displays as \`{agent_dir_display}\`)
-**Project Memory Location**: {project_memory_info}
-
-Your system prompt is loaded from TWO sources at startup:
-1. **User agent.md**: \`{agent_dir_absolute}/agent.md\` - Your personal preferences across all projects
-2. **Project agent.md**: Loaded from project root if available - Project-specific instructions
-
-Project-specific agent.md is loaded from these locations (both combined if both exist):
-- \`[project-root]/.deepagents/agent.md\` (preferred)
-- \`[project-root]/agent.md\` (fallback, but also included if both exist)
-
-**When to CHECK/READ memories (CRITICAL - do this FIRST):**
-- **At the start of ANY new session**: Check both user and project memories
-  - User: \`ls {agent_dir_absolute}\`
-  - Project: \`ls {project_deepagents_dir}\` (if in a project)
-- **BEFORE answering questions**: If asked "what do you know about X?" or "how do I do Y?", check project memories FIRST, then user
-- **When user asks you to do something**: Check if you have project-specific guides or examples
-- **When user references past work**: Search project memory files for related context
-
-**Memory-first response pattern:**
-1. User asks a question → Check project directory first: \`ls {project_deepagents_dir}\`
-2. If relevant files exist → Read them with \`read_file '{project_deepagents_dir}/[filename]'\`
-3. Check user memory if needed → \`ls {agent_dir_absolute}\`
-4. Base your answer on saved knowledge supplemented by general knowledge
-
-**When to update memories:**
-- **IMMEDIATELY when the user describes your role or how you should behave**
-- **IMMEDIATELY when the user gives feedback on your work** - Update memories to capture what was wrong and how to do it better
-- When the user explicitly asks you to remember something
-- When patterns or preferences emerge (coding styles, conventions, workflows)
-- After significant work where context would help in future sessions
-
-**Learning from feedback:**
-- When user says something is better/worse, capture WHY and encode it as a pattern
-- Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions
-- When user says "you should remember X" or "be careful about Y", treat this as HIGH PRIORITY - update memories IMMEDIATELY
-- Look for the underlying principle behind corrections, not just the specific mistake
-
-## Deciding Where to Store Memory
-
-When writing or updating agent memory, decide whether each fact, configuration, or behavior belongs in:
-
-### User Agent File: \`{agent_dir_absolute}/agent.md\`
-→ Describes the agent's **personality, style, and universal behavior** across all projects.
-
-**Store here:**
-- Your general tone and communication style
-- Universal coding preferences (formatting, comment style, etc.)
-- General workflows and methodologies you follow
-- Tool usage patterns that apply everywhere
-- Personal preferences that don't change per-project
-
-**Examples:**
-- "Be concise and direct in responses"
-- "Always use type hints in Python"
-- "Prefer functional programming patterns"
-
-### Project Agent File: \`{project_deepagents_dir}/agent.md\`
-→ Describes **how this specific project works** and **how the agent should behave here only.**
-
-**Store here:**
-- Project-specific architecture and design patterns
-- Coding conventions specific to this codebase
-- Project structure and organization
-- Testing strategies for this project
-- Deployment processes and workflows
-- Team conventions and guidelines
-
-**Examples:**
-- "This project uses FastAPI with SQLAlchemy"
-- "Tests go in tests/ directory mirroring src/ structure"
-- "All API changes require updating OpenAPI spec"
-
-### Project Memory Files: \`{project_deepagents_dir}/*.md\`
-→ Use for **project-specific reference information** and structured notes.
-
-**Store here:**
-- API design documentation
-- Architecture decisions and rationale
-- Deployment procedures
-- Common debugging patterns
-- Onboarding information
-
-**Examples:**
-- \`{project_deepagents_dir}/api-design.md\` - REST API patterns used
-- \`{project_deepagents_dir}/architecture.md\` - System architecture overview
-- \`{project_deepagents_dir}/deployment.md\` - How to deploy this project
-
-### File Operations:
-
-**User memory:**
-\`\`\`
-ls {agent_dir_absolute}                              # List user memory files
-read_file '{agent_dir_absolute}/agent.md'            # Read user preferences
-edit_file '{agent_dir_absolute}/agent.md' ...        # Update user preferences
-\`\`\`
-
-**Project memory (preferred for project-specific information):**
-\`\`\`
-ls {project_deepagents_dir}                          # List project memory files
-read_file '{project_deepagents_dir}/agent.md'        # Read project instructions
-edit_file '{project_deepagents_dir}/agent.md' ...    # Update project instructions
-write_file '{project_deepagents_dir}/agent.md' ...  # Create project memory file
-\`\`\`
-
-**Important**:
-- Project memory files are stored in \`.deepagents/\` inside the project root
-- Always use absolute paths for file operations
-- Check project memories BEFORE user when answering project-specific questions`;
-/**
-* Create middleware for loading agent-specific long-term memory.
-*
-* This middleware loads the agent's long-term memory from a file (agent.md)
-* and injects it into the system prompt. The memory is loaded once at the
-* start of the conversation and stored in state.
-*
-* @param options - Configuration options
-* @returns AgentMiddleware for memory loading and injection
-*/
-function createAgentMemoryMiddleware(options) {
-	const { settings, assistantId, systemPromptTemplate } = options;
-	const agentDir = settings.getAgentDir(assistantId);
-	const agentDirDisplay = `~/.deepagents/${assistantId}`;
-	const agentDirAbsolute = agentDir;
-	const projectRoot = settings.projectRoot;
-	const projectMemoryInfo = projectRoot ? `\`${projectRoot}\` (detected)` : "None (not in a git project)";
-	const projectDeepagentsDir = projectRoot ? `${projectRoot}/.deepagents` : "[project-root]/.deepagents (not in a project)";
-	const template = systemPromptTemplate || DEFAULT_MEMORY_TEMPLATE;
-	return createMiddleware({
-		name: "AgentMemoryMiddleware",
-		stateSchema: AgentMemoryStateSchema,
-		beforeAgent(state) {
-			const result = {};
-			if (!("userMemory" in state)) {
-				const userPath = settings.getUserAgentMdPath(assistantId);
-				if (fs$1.existsSync(userPath)) try {
-					result.userMemory = fs$1.readFileSync(userPath, "utf-8");
-				} catch {}
-			}
-			if (!("projectMemory" in state)) {
-				const projectPath = settings.getProjectAgentMdPath();
-				if (projectPath && fs$1.existsSync(projectPath)) try {
-					result.projectMemory = fs$1.readFileSync(projectPath, "utf-8");
-				} catch {}
-			}
-			return Object.keys(result).length > 0 ? result : void 0;
-		},
-		wrapModelCall(request, handler) {
-			const userMemory = request.state?.userMemory;
-			const projectMemory = request.state?.projectMemory;
-			const baseSystemPrompt = request.systemPrompt || "";
-			const memorySection = template.replace("{user_memory}", userMemory || "(No user agent.md)").replace("{project_memory}", projectMemory || "(No project agent.md)");
-			const memoryDocs = LONGTERM_MEMORY_SYSTEM_PROMPT.replaceAll("{agent_dir_absolute}", agentDirAbsolute).replaceAll("{agent_dir_display}", agentDirDisplay).replaceAll("{project_memory_info}", projectMemoryInfo).replaceAll("{project_deepagents_dir}", projectDeepagentsDir);
-			let systemPrompt = memorySection;
-			if (baseSystemPrompt) systemPrompt += "\n\n" + baseSystemPrompt;
-			systemPrompt += "\n\n" + memoryDocs;
-			return handler({
-				...request,
-				systemPrompt
-			});
-		}
-	});
-}
-
-//#endregion
-export { BaseSandbox, CompositeBackend, FilesystemBackend, MAX_SKILL_DESCRIPTION_LENGTH, MAX_SKILL_FILE_SIZE, MAX_SKILL_NAME_LENGTH, StateBackend, StoreBackend, createAgentMemoryMiddleware, createDeepAgent, createFilesystemMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgentMiddleware, findProjectRoot, isSandboxBackend, listSkills, parseSkillMetadata };
+export { BaseSandbox, CompositeBackend, FilesystemBackend, MAX_SKILL_DESCRIPTION_LENGTH, MAX_SKILL_FILE_SIZE, MAX_SKILL_NAME_LENGTH, StateBackend, StoreBackend, createAgentMemoryMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgentMiddleware, findProjectRoot, isSandboxBackend, listSkills, parseSkillMetadata };
 //# sourceMappingURL=index.js.map