deepagents 1.10.0 → 1.10.2

package/dist/index.cjs

@@ -46,6 +46,7 @@ let node_child_process = require("node:child_process");
 node_child_process = __toESM(node_child_process, 1);
 let fast_glob = require("fast-glob");
 fast_glob = __toESM(fast_glob, 1);
+let langsmith = require("langsmith");
 let langsmith_experimental_sandbox = require("langsmith/experimental/sandbox");
 let node_os = require("node:os");
 node_os = __toESM(node_os, 1);
@@ -5726,6 +5727,341 @@ var FilesystemBackend = class {
 	}
 };
 //#endregion
+//#region src/backends/context-hub.ts
+/**
+* ContextHubBackend: Store files in a LangSmith Hub agent repo (persistent).
+*/
+const URL_COMMIT_SUFFIX_RE = /:([0-9a-f]{8,64})$/i;
+const TEXT_MIME_TYPE = "text/plain";
+const FNMATCH_OPTIONS = { bash: true };
+function getErrorMessage(error) {
+	if (typeof error === "string") return error;
+	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return error.message;
+	return String(error);
+}
+function splitLinesKeepEnds(content) {
+	const lines = [];
+	let lineStart = 0;
+	for (let index = 0; index < content.length; index += 1) if (content[index] === "\n") {
+		lines.push(content.slice(lineStart, index + 1));
+		lineStart = index + 1;
+	}
+	if (lineStart < content.length) lines.push(content.slice(lineStart));
+	return lines;
+}
+function sliceReadContent(content, offset, limit) {
+	if (!content || content.trim() === "") return { content };
+	const lines = splitLinesKeepEnds(content.replace(/\r\n/g, "\n").replace(/\r/g, "\n"));
+	const startIndex = offset;
+	const endIndex = Math.min(startIndex + limit, lines.length);
+	if (startIndex >= lines.length) return { error: `Line offset ${offset} exceeds file length (${lines.length} lines)` };
+	return { content: lines.slice(startIndex, endIndex).join("") };
+}
+function isLangSmithNotFoundError(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const maybeError = error;
+	return maybeError.name === "LangSmithNotFoundError" || maybeError.status === 404;
+}
+function isLangSmithError(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const maybeError = error;
+	return typeof maybeError.name === "string" && maybeError.name.startsWith("LangSmith") || typeof maybeError.status === "number";
+}
+function getLangSmithStatus(error) {
+	if (typeof error !== "object" || error === null) return;
+	const maybeError = error;
+	if (typeof maybeError.status === "number") return maybeError.status;
+}
+function mapHubFileOperationError(error) {
+	const status = getLangSmithStatus(error);
+	if (status === 401 || status === 403) return "permission_denied";
+	if (status === 404) return "file_not_found";
+	return "invalid_path";
+}
+/**
+* Backend that stores files in a LangSmith Hub agent repo (persistent).
+*/
+var ContextHubBackend = class ContextHubBackend {
+	identifier;
+	client;
+	cache = null;
+	linkedEntries = {};
+	commitHash = null;
+	constructor(identifier, options = {}) {
+		this.identifier = identifier;
+		this.client = options.client ?? new langsmith.Client();
+	}
+	static stripPrefix(path) {
+		return path.replace(/^\/+/, "");
+	}
+	static toHubUnavailableError(error) {
+		return `Hub unavailable: ${getErrorMessage(error)}`;
+	}
+	async loadTree() {
+		let context;
+		try {
+			context = await this.client.pullAgent(this.identifier);
+		} catch (error) {
+			if (isLangSmithNotFoundError(error)) {
+				this.cache = {};
+				this.linkedEntries = {};
+				this.commitHash = null;
+				return;
+			}
+			throw error;
+		}
+		this.commitHash = context.commit_hash;
+		this.cache = {};
+		this.linkedEntries = {};
+		for (const [path, entry] of Object.entries(context.files)) if (entry.type === "file") this.cache[path] = entry.content;
+		else if ((entry.type === "agent" || entry.type === "skill") && typeof entry.repo_handle === "string") this.linkedEntries[path] = entry.repo_handle;
+	}
+	async ensureCache() {
+		if (this.cache === null) await this.loadTree();
+		if (this.cache === null) throw new Error("Context Hub cache failed to initialize");
+		return this.cache;
+	}
+	async commit(files) {
+		if (Object.keys(files).length === 0) return;
+		const payload = {};
+		for (const [path, content] of Object.entries(files)) payload[path] = {
+			type: "file",
+			content
+		};
+		const url = await this.client.pushAgent(this.identifier, {
+			files: payload,
+			...this.commitHash ? { parentCommit: this.commitHash } : {}
+		});
+		const match = URL_COMMIT_SUFFIX_RE.exec(url);
+		if (match) this.commitHash = match[1];
+		if (this.cache !== null) for (const [path, content] of Object.entries(files)) this.cache[path] = content;
+	}
+	/**
+	* Return linked-entry paths mapped to their repo handles.
+	*/
+	async getLinkedEntries() {
+		await this.ensureCache();
+		return { ...this.linkedEntries };
+	}
+	/**
+	* Return true if the hub repo already exists with at least one commit.
+	*/
+	async hasPriorCommits() {
+		await this.ensureCache();
+		return this.commitHash !== null;
+	}
+	async ls(path = "/") {
+		const hubPrefix = ContextHubBackend.stripPrefix(path).replace(/\/+$/, "");
+		let cache;
+		try {
+			cache = await this.ensureCache();
+		} catch (error) {
+			if (isLangSmithError(error)) return { error: ContextHubBackend.toHubUnavailableError(error) };
+			throw error;
+		}
+		const dirs = /* @__PURE__ */ new Set();
+		const entries = [];
+		for (const filePath of Object.keys(cache)) {
+			if (hubPrefix && !filePath.startsWith(`${hubPrefix}/`)) continue;
+			const relative = hubPrefix ? filePath.slice(hubPrefix.length + 1) : filePath;
+			if (!relative) continue;
+			const slashIndex = relative.indexOf("/");
+			if (slashIndex === -1) {
+				entries.push({
+					path: `/${filePath}`,
+					is_dir: false
+				});
+				continue;
+			}
+			const dirName = relative.slice(0, slashIndex);
+			const dirPath = hubPrefix ? `${hubPrefix}/${dirName}` : dirName;
+			if (!dirs.has(dirPath)) {
+				dirs.add(dirPath);
+				entries.push({
+					path: `/${dirPath}`,
+					is_dir: true
+				});
+			}
+		}
+		return { files: entries };
+	}
+	async read(filePath, offset = 0, limit = 2e3) {
+		const hubPath = ContextHubBackend.stripPrefix(filePath);
+		let cache;
+		try {
+			cache = await this.ensureCache();
+		} catch (error) {
+			if (isLangSmithError(error)) return { error: ContextHubBackend.toHubUnavailableError(error) };
+			throw error;
+		}
+		const content = cache[hubPath];
+		if (content === void 0) return { error: `File '${filePath}' not found` };
+		const sliced = sliceReadContent(content, offset, limit);
+		if (sliced.error) return { error: sliced.error };
+		return {
+			content: sliced.content ?? "",
+			mimeType: TEXT_MIME_TYPE
+		};
+	}
+	async readRaw(filePath) {
+		const readResult = await this.read(filePath, 0, Number.MAX_SAFE_INTEGER);
+		if (readResult.error || typeof readResult.content !== "string") return { error: readResult.error ?? `File '${filePath}' not found` };
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return { data: {
+			content: readResult.content,
+			mimeType: TEXT_MIME_TYPE,
+			created_at: now,
+			modified_at: now
+		} };
+	}
+	async grep(pattern, path = null, glob = null) {
+		let cache;
+		try {
+			cache = await this.ensureCache();
+		} catch (error) {
+			if (isLangSmithError(error)) return { error: ContextHubBackend.toHubUnavailableError(error) };
+			throw error;
+		}
+		const prefix = path ? ContextHubBackend.stripPrefix(path).replace(/\/+$/, "") : "";
+		const matches = [];
+		for (const [filePath, content] of Object.entries(cache)) {
+			if (prefix && !filePath.startsWith(prefix)) continue;
+			if (glob && !micromatch.default.isMatch(filePath, glob, FNMATCH_OPTIONS)) continue;
+			const lines = content.split("\n");
+			for (let index = 0; index < lines.length; index++) {
+				const line = lines[index];
+				if (line.includes(pattern)) matches.push({
+					path: `/${filePath}`,
+					line: index + 1,
+					text: line
+				});
+			}
+		}
+		return { matches };
+	}
+	async glob(pattern, _path = "/") {
+		let cache;
+		try {
+			cache = await this.ensureCache();
+		} catch (error) {
+			if (isLangSmithError(error)) return { error: ContextHubBackend.toHubUnavailableError(error) };
+			throw error;
+		}
+		const files = [];
+		for (const filePath of Object.keys(cache)) if (micromatch.default.isMatch(`/${filePath}`, pattern, FNMATCH_OPTIONS) || micromatch.default.isMatch(filePath, pattern, FNMATCH_OPTIONS)) files.push({
+			path: `/${filePath}`,
+			is_dir: false
+		});
+		return { files };
+	}
+	async write(filePath, content) {
+		const hubPath = ContextHubBackend.stripPrefix(filePath);
+		try {
+			await this.ensureCache();
+			await this.commit({ [hubPath]: content });
+		} catch (error) {
+			if (isLangSmithError(error)) {
+				this.cache = null;
+				return { error: ContextHubBackend.toHubUnavailableError(error) };
+			}
+			throw error;
+		}
+		return {
+			path: filePath,
+			filesUpdate: null
+		};
+	}
+	async edit(filePath, oldString, newString, replaceAll = false) {
+		const hubPath = ContextHubBackend.stripPrefix(filePath);
+		try {
+			const current = (await this.ensureCache())[hubPath];
+			if (current === void 0) return { error: `Error: File '${filePath}' not found` };
+			const replacementResult = performStringReplacement(current, oldString, newString, replaceAll);
+			if (typeof replacementResult === "string") return { error: replacementResult };
+			const [newContent, occurrences] = replacementResult;
+			await this.commit({ [hubPath]: newContent });
+			return {
+				path: filePath,
+				filesUpdate: null,
+				occurrences
+			};
+		} catch (error) {
+			if (isLangSmithError(error)) {
+				this.cache = null;
+				return { error: ContextHubBackend.toHubUnavailableError(error) };
+			}
+			throw error;
+		}
+	}
+	async uploadFiles(files) {
+		const decoder = new TextDecoder("utf-8", { fatal: true });
+		const decoded = [];
+		const validFiles = {};
+		for (const [path, content] of files) try {
+			const text = decoder.decode(content);
+			decoded.push([path, text]);
+			validFiles[ContextHubBackend.stripPrefix(path)] = text;
+		} catch {
+			decoded.push([path, null]);
+		}
+		let commitError = null;
+		if (Object.keys(validFiles).length > 0) try {
+			await this.ensureCache();
+			await this.commit(validFiles);
+		} catch (error) {
+			if (isLangSmithError(error)) {
+				this.cache = null;
+				commitError = mapHubFileOperationError(error);
+			} else throw error;
+		}
+		return decoded.map(([path, text]) => {
+			if (text === null) return {
+				path,
+				error: "invalid_path"
+			};
+			if (commitError !== null) return {
+				path,
+				error: commitError
+			};
+			return {
+				path,
+				error: null
+			};
+		});
+	}
+	async downloadFiles(paths) {
+		let cache;
+		try {
+			cache = await this.ensureCache();
+		} catch (error) {
+			if (isLangSmithError(error)) {
+				const mappedError = mapHubFileOperationError(error);
+				return paths.map((path) => ({
+					path,
+					content: null,
+					error: mappedError
+				}));
+			}
+			throw error;
+		}
+		const encoder = new TextEncoder();
+		return paths.map((path) => {
+			const hubPath = ContextHubBackend.stripPrefix(path);
+			const content = cache[hubPath];
+			if (content !== void 0) return {
+				path,
+				content: encoder.encode(content),
+				error: null
+			};
+			return {
+				path,
+				content: null,
+				error: "file_not_found"
+			};
+		});
+	}
+};
+//#endregion
 //#region src/backends/local-shell.ts
 /**
 * LocalShellBackend: Node.js implementation of the filesystem backend with unrestricted local shell execution.
@@ -6464,7 +6800,7 @@ var BaseSandbox = class {
 * ```typescript
 * import { LangSmithSandbox, createDeepAgent } from "deepagents";
 *
-* const sandbox = await LangSmithSandbox.create({ templateName: "deepagents-cli" });
+* const sandbox = await LangSmithSandbox.create({ snapshotId: "your-snapshot-id" });
 *
 * const agent = createDeepAgent({ model, backend: sandbox });
 *
@@ -6588,6 +6924,41 @@ var LangSmithSandbox = class LangSmithSandbox extends BaseSandbox {
 		this.#isRunning = false;
 	}
 	/**
+	* Start a stopped sandbox and wait until it is ready.
+	*
+	* After calling this, `isRunning` will be `true` and the sandbox
+	* can be used for command execution and file operations again.
+	*
+	* @param options - Start options (timeout, signal).
+	*/
+	async start(options = {}) {
+		await this.#sandbox.start(options);
+		this.#isRunning = true;
+	}
+	/**
+	* Stop the sandbox without deleting it.
+	*
+	* Sandbox files are preserved and the sandbox can be restarted later
+	* with `start()`. After calling this, `isRunning` will be `false`.
+	*/
+	async stop() {
+		await this.#sandbox.stop();
+		this.#isRunning = false;
+	}
+	/**
+	* Capture a snapshot from this running sandbox.
+	*
+	* Snapshots can be used to create new sandboxes via
+	* `LangSmithSandbox.create({ snapshotId })`.
+	*
+	* @param name - Name for the snapshot.
+	* @param options - Capture options (checkpoint, timeout).
+	* @returns The created Snapshot in "ready" status.
+	*/
+	async captureSnapshot(name, options = {}) {
+		return this.#sandbox.captureSnapshot(name, options);
+	}
+	/**
 	* Create and return a new LangSmithSandbox in one step.
 	*
 	* This is the recommended way to create a sandbox — no need to import
@@ -6595,7 +6966,10 @@ var LangSmithSandbox = class LangSmithSandbox extends BaseSandbox {
 	*
 	* @example
 	* ```typescript
-	* const sandbox = await LangSmithSandbox.create({ templateName: "deepagents" });
+	* const sandbox = await LangSmithSandbox.create({
+	*   snapshotId: "abc-123",
+	* });
+	*
 	* try {
 	*   const agent = createDeepAgent({ model, backend: sandbox });
 	*   await agent.invoke({ messages: [...] });
@@ -6604,10 +6978,14 @@ var LangSmithSandbox = class LangSmithSandbox extends BaseSandbox {
 	* }
 	* ```
 	*/
-	static async create(options = {}) {
-		const { templateName = "deepagents", apiKey = process.env.LANGSMITH_API_KEY, defaultTimeout, ...createSandboxOptions } = options;
+	static async create(options) {
+		const { templateName, apiKey = process.env.LANGSMITH_API_KEY, defaultTimeout, snapshotId, ...createSandboxOptions } = options;
+		if (snapshotId && templateName) throw new Error("snapshotId and templateName are mutually exclusive. Pass only one creation source.");
+		if (!snapshotId && !templateName) throw new Error("Either snapshotId or templateName is required. snapshotId is recommended — template-based creation is deprecated.");
+		const sandboxOptions = { ...createSandboxOptions };
+		if (templateName) sandboxOptions.snapshotName = templateName;
 		return new LangSmithSandbox({
-			sandbox: await new langsmith_experimental_sandbox.SandboxClient({ apiKey }).createSandbox(templateName, createSandboxOptions),
+			sandbox: await new langsmith_experimental_sandbox.SandboxClient({ apiKey }).createSandbox(snapshotId, sandboxOptions),
 			defaultTimeout
 		});
 	}
@@ -6959,6 +7337,717 @@ function createSubagentTransformer(path) {
 	};
 }
 //#endregion
+//#region src/profiles/keys.ts
+/**
+* Normalize and validate a profile registry key.
+*
+* Trims leading/trailing whitespace, then enforces the `"provider"` or
+* `"provider:model"` shape. Rejects empty strings, multiple colons, and
+* empty halves.
+*
+* @param key - The registry key to validate.
+* @returns The trimmed, validated key.
+* @throws {Error} When the key is malformed.
+*
+* @example
+* ```typescript
+* validateProfileKey("anthropic:claude-opus-4-7"); // "anthropic:claude-opus-4-7"
+* validateProfileKey("  openai  ");                 // "openai"
+* validateProfileKey("openai:");                    // throws
+* validateProfileKey("");                            // throws
+* ```
+*/
+function validateProfileKey(key) {
+	const trimmed = key.trim();
+	if (!trimmed) throw new Error("Profile key must be a non-empty string");
+	if (trimmed.split(":").length > 2) throw new Error(`Profile key "${trimmed}" has more than one ":"; expected "provider" or "provider:model"`);
+	if (trimmed.includes(":")) {
+		const [provider, model] = trimmed.split(":");
+		if (!provider.trim() || !model.trim()) throw new Error(`Profile key "${trimmed}" has an empty provider or model half; expected "provider:model"`);
+	}
+	return trimmed;
+}
+//#endregion
+//#region src/profiles/harness/types.ts
+/**
+* Middleware names that provide essential agent capabilities and cannot
+* be excluded via `excludedMiddleware`.
+*
+* - `FilesystemMiddleware` backs all built-in file tools and enforces
+*   filesystem permissions.
+* - `SubAgentMiddleware` backs the `task` tool for subagent delegation.
+*/
+const REQUIRED_MIDDLEWARE_NAMES = new Set(["FilesystemMiddleware", "SubAgentMiddleware"]);
+/**
+* Type guard: is this a fully-constructed HarnessProfile (frozen with
+* Set fields) or raw options?
+*
+* Options use arrays for `excludedTools`; profiles use `Set`. We
+* distinguish by checking whether `excludedTools` has a `.has` method
+* (present on Set, absent on Array).
+*/
+function isHarnessProfile(value) {
+	return value.excludedTools != null && typeof value.excludedTools.has === "function" && !Array.isArray(value.excludedTools);
+}
+/**
+* Resolve middleware to a concrete array, invoking the factory if
+* needed.
+*
+* @internal
+*/
+function resolveMiddleware(middleware) {
+	if (typeof middleware === "function") return middleware();
+	return middleware;
+}
+//#endregion
+//#region src/profiles/harness/create.ts
+/**
+* Validate the grammar of an `excludedMiddleware` entry.
+*
+* Runs at profile construction time so malformed entries fail
+* immediately. Checks:
+*
+* 1. Non-empty, non-whitespace string.
+* 2. No colons (class-path `module:Class` syntax is reserved).
+* 3. No underscore prefix (private middleware is not part of the
+*    exclusion surface).
+* 4. Not a required scaffolding name.
+*
+* @param name - The middleware name to validate.
+* @throws {Error} When the name violates any rule.
+*/
+function validateExcludedMiddlewareName(name) {
+	if (!name || !name.trim()) throw new Error("excludedMiddleware entries must be non-empty, non-whitespace strings.");
+	if (name.includes(":")) throw new Error(`excludedMiddleware entries must be plain middleware names; class-path syntax is not supported, got "${name}".`);
+	if (name.startsWith("_")) throw new Error(`excludedMiddleware entry "${name}" cannot start with "_" (underscore-prefixed names refer to private middleware not part of the public exclusion surface).`);
+	if (REQUIRED_MIDDLEWARE_NAMES.has(name)) throw new Error(`Cannot exclude required middleware "${name}" — it provides essential agent capabilities that the runtime depends on.`);
+}
+/**
+* Create a frozen {@link HarnessProfile} from user-provided options.
+*
+* Validates all fields, converts mutable collections to their
+* frozen counterparts, and returns a frozen object.
+* Empty options produce a no-op profile (all defaults).
+*
+* @param options - Partial profile configuration.
+* @returns A frozen, validated `HarnessProfile`.
+* @throws {Error} When any field violates validation rules (invalid
+*   middleware names, scaffolding exclusion attempts).
+*
+* @example
+* ```typescript
+* const profile = createHarnessProfile({
+*   systemPromptSuffix: "Think step by step.",
+*   excludedTools: ["execute"],
+* });
+* ```
+*/
+function createHarnessProfile(options = {}) {
+	for (const name of options.excludedMiddleware ?? []) validateExcludedMiddlewareName(name);
+	const toolDescriptionOverrides = Object.freeze(Object.assign(Object.create(null), options.toolDescriptionOverrides));
+	const generalPurposeSubagent = options.generalPurposeSubagent ? Object.freeze({ ...options.generalPurposeSubagent }) : void 0;
+	const profile = {
+		baseSystemPrompt: options.baseSystemPrompt,
+		systemPromptSuffix: options.systemPromptSuffix,
+		toolDescriptionOverrides,
+		excludedTools: new Set(options.excludedTools),
+		excludedMiddleware: new Set(options.excludedMiddleware),
+		extraMiddleware: options.extraMiddleware ?? [],
+		generalPurposeSubagent
+	};
+	return Object.freeze(profile);
+}
+/**
+* An empty no-op profile used as the default when no registered
+* profile matches. Avoids creating a new object on every miss.
+*/
+const EMPTY_HARNESS_PROFILE = createHarnessProfile();
+//#endregion
+//#region src/profiles/harness/serialization.ts
+const POISONED_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* Zod schema for the general-purpose subagent config section of an
+* external harness profile config file.
+*/
+const generalPurposeSubagentConfigSchema = zod_v4.z.object({
+	enabled: zod_v4.z.boolean().optional(),
+	description: zod_v4.z.string().optional(),
+	systemPrompt: zod_v4.z.string().optional()
+}).strict();
+/**
+* Zod schema for parsing a harness profile from an external JSON or
+* YAML config file.
+*
+* Uses `.strict()` to reject unknown keys (catches typos early). Array
+* fields (`excludedTools`, `excludedMiddleware`) accept arrays of
+* strings; the result is passed to {@link createHarnessProfile} which
+* converts them to `Set`.
+*
+* Does not include `extraMiddleware` — middleware instances cannot be
+* represented in JSON/YAML.
+*
+* @example
+* ```typescript
+* import { readFileSync } from "fs";
+* import YAML from "yaml";
+*
+* const raw = YAML.parse(readFileSync("profile.yaml", "utf-8"));
+* const config = harnessProfileConfigSchema.parse(raw);
+* const profile = createHarnessProfile(config);
+* ```
+*/
+const harnessProfileConfigSchema = zod_v4.z.object({
+	baseSystemPrompt: zod_v4.z.string().optional(),
+	systemPromptSuffix: zod_v4.z.string().optional(),
+	toolDescriptionOverrides: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
+	excludedTools: zod_v4.z.array(zod_v4.z.string()).optional(),
+	excludedMiddleware: zod_v4.z.array(zod_v4.z.string()).optional(),
+	generalPurposeSubagent: generalPurposeSubagentConfigSchema.optional()
+}).strict();
+/**
+* Recursively check an object for prototype-pollution keys.
+*
+* Rejects `__proto__`, `constructor`, and `prototype` at any nesting
+* depth. Called before Zod parsing so poisoned payloads never reach
+* schema validation.
+*/
+function rejectPoisonedKeys(value, path = "") {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+	for (const key of Object.keys(value)) {
+		if (POISONED_KEYS.has(key)) throw new Error(`Rejected dangerous key "${key}" at ${path || "root"} in harness profile config.`);
+		rejectPoisonedKeys(value[key], path ? `${path}.${key}` : key);
+	}
+}
+/**
+* Parse an untrusted JSON/YAML object into a validated
+* {@link HarnessProfile}.
+*
+* Combines Zod schema validation with prototype-pollution protection
+* and profile construction validation. Use this for any config data
+* that originates from files, network, or user input.
+*
+* @param data - Raw object from `JSON.parse()` or `YAML.parse()`.
+* @returns A frozen, validated `HarnessProfile`.
+* @throws {z.ZodError} When the data fails schema validation.
+* @throws {Error} When profile-level validation fails (e.g.,
+*   scaffolding violation in `excludedMiddleware`).
+*/
+function parseHarnessProfileConfig(data) {
+	rejectPoisonedKeys(data);
+	return createHarnessProfile(harnessProfileConfigSchema.parse(data));
+}
+/**
+* Serialize a {@link HarnessProfile} to a JSON-compatible object.
+*
+* Omits `undefined` fields and `extraMiddleware` (runtime-only).
+* Throws if `extraMiddleware` contains instances — callers should
+* strip it before serializing if they've set it.
+*
+* @param profile - The profile to serialize.
+* @returns A plain object matching {@link HarnessProfileConfigData}.
+* @throws {Error} When `extraMiddleware` is non-empty (cannot be
+*   serialized to JSON).
+*/
+function serializeProfile(profile) {
+	if (resolveMiddleware(profile.extraMiddleware).length > 0) throw new Error("Cannot serialize a HarnessProfile with non-empty extraMiddleware — middleware instances are runtime-only and have no JSON representation.");
+	const result = {};
+	if (profile.baseSystemPrompt !== void 0) result.baseSystemPrompt = profile.baseSystemPrompt;
+	if (profile.systemPromptSuffix !== void 0) result.systemPromptSuffix = profile.systemPromptSuffix;
+	if (Object.keys(profile.toolDescriptionOverrides).length > 0) result.toolDescriptionOverrides = { ...profile.toolDescriptionOverrides };
+	if (profile.excludedTools.size > 0) result.excludedTools = [...profile.excludedTools];
+	if (profile.excludedMiddleware.size > 0) result.excludedMiddleware = [...profile.excludedMiddleware];
+	if (profile.generalPurposeSubagent !== void 0) {
+		const gp = {};
+		if (profile.generalPurposeSubagent.enabled !== void 0) gp.enabled = profile.generalPurposeSubagent.enabled;
+		if (profile.generalPurposeSubagent.description !== void 0) gp.description = profile.generalPurposeSubagent.description;
+		if (profile.generalPurposeSubagent.systemPrompt !== void 0) gp.systemPrompt = profile.generalPurposeSubagent.systemPrompt;
+		if (Object.keys(gp).length > 0) result.generalPurposeSubagent = gp;
+	}
+	return result;
+}
+//#endregion
+//#region src/profiles/harness/merge.ts
+/**
+* Merge two middleware sequences by `.name`.
+*
+* When the override has a middleware whose `.name` already appears in
+* the base, the override instance replaces the base instance at the
+* same position. Novel names from the override are appended. If the
+* base has duplicates of the same name, only the first is replaced;
+* later duplicates are dropped.
+*
+* Returns a factory to ensure fresh resolution on each call.
+*/
+function mergeMiddleware(base, override) {
+	const baseArr = resolveMiddleware(base);
+	const overrideArr = resolveMiddleware(override);
+	if (baseArr.length === 0) return override;
+	if (overrideArr.length === 0) return base;
+	return () => {
+		const baseSeq = resolveMiddleware(base);
+		const overrideSeq = resolveMiddleware(override);
+		const overrideByName = new Map(overrideSeq.map((m) => [m.name, m]));
+		const merged = [];
+		const replaced = /* @__PURE__ */ new Set();
+		for (const entry of baseSeq) {
+			const replacement = overrideByName.get(entry.name);
+			if (replacement) {
+				if (!replaced.has(entry.name)) {
+					merged.push(replacement);
+					replaced.add(entry.name);
+				}
+			} else merged.push(entry);
+		}
+		for (const entry of overrideSeq) if (!replaced.has(entry.name)) merged.push(entry);
+		return merged;
+	};
+}
+/**
+* Merge two GP subagent configs field-wise.
+*
+* Override wins per sub-field when not `undefined`; unset fields
+* inherit from base. Returns `undefined` only when both inputs are
+* `undefined`.
+*/
+function mergeGeneralPurposeSubagentConfigs(base, override) {
+	if (base === void 0) return override;
+	if (override === void 0) return base;
+	return {
+		enabled: override.enabled ?? base.enabled,
+		description: override.description ?? base.description,
+		systemPrompt: override.systemPrompt ?? base.systemPrompt
+	};
+}
+/**
+* Merge two harness profiles, layering `override` on top of `base`.
+*
+* Merge semantics per field:
+*
+* | Field | Strategy |
+* |-------|----------|
+* | `baseSystemPrompt` | Override wins if not `undefined` |
+* | `systemPromptSuffix` | Override wins if not `undefined` |
+* | `toolDescriptionOverrides` | Object spread merge; override wins per key |
+* | `excludedTools` | Set union |
+* | `excludedMiddleware` | Set union |
+* | `extraMiddleware` | Merge by `.name`; override instance replaces base at same position; novel names appended |
+* | `generalPurposeSubagent` | Field-wise merge; override wins per sub-field |
+*
+* @param base - Lower-priority profile (e.g., provider-wide).
+* @param override - Higher-priority profile (e.g., exact model).
+* @returns A new merged profile.
+*/
+function mergeProfiles(base, override) {
+	return createHarnessProfile({
+		baseSystemPrompt: override.baseSystemPrompt ?? base.baseSystemPrompt,
+		systemPromptSuffix: override.systemPromptSuffix ?? base.systemPromptSuffix,
+		toolDescriptionOverrides: {
+			...base.toolDescriptionOverrides,
+			...override.toolDescriptionOverrides
+		},
+		excludedTools: [...base.excludedTools, ...override.excludedTools],
+		excludedMiddleware: [...base.excludedMiddleware, ...override.excludedMiddleware],
+		extraMiddleware: mergeMiddleware(base.extraMiddleware, override.extraMiddleware),
+		generalPurposeSubagent: mergeGeneralPurposeSubagentConfigs(base.generalPurposeSubagent, override.generalPurposeSubagent)
+	});
+}
+//#endregion
+//#region src/profiles/harness/builtins/anthropic-opus-4-7.ts
+const SYSTEM_PROMPT_SUFFIX$3 = `\
+<use_parallel_tool_calls>
+If you intend to call multiple tools and there are no dependencies between the tool calls, make all of the independent tool calls in parallel. Prioritize calling tools simultaneously whenever the actions can be done in parallel rather than sequentially. For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into context at the same time. Maximize use of parallel tool calls where possible to increase speed and efficiency. However, if some tool calls depend on previous calls to inform dependent values like the parameters, do NOT call these tools in parallel and instead call them sequentially. Never use placeholders or guess missing parameters in tool calls.
+</use_parallel_tool_calls>
+
+<investigate_before_answering>
+Never speculate about code you have not opened. If the user references a specific file, you MUST read the file before answering. Make sure to investigate and read relevant files BEFORE answering questions about the codebase. Never make any claims about code before investigating unless you are certain of the correct answer - give grounded and hallucination-free answers.
+</investigate_before_answering>
+
+<tool_result_reflection>
+After receiving tool results, carefully reflect on their quality and determine optimal next steps before proceeding. Use your thinking to plan and iterate based on this new information, and then take the best next action.
+</tool_result_reflection>
+
+<tool_usage>
+When a task depends on the state of files, tests, or system output, use tools to observe that state directly rather than reasoning from memory about what it probably contains. Read files before describing them. Run tests before claiming they pass. Search the codebase before asserting a symbol does or does not exist. Active investigation with tools is the default mode of working, not a fallback.
+</tool_usage>
+
+<subagent_usage>
+Do not spawn a subagent for work you can complete directly in a single response (e.g. refactoring a function you can already see).
+
+Spawn multiple subagents in the same turn when fanning out across items or reading multiple files.
+</subagent_usage>`;
+/**
+* Register the built-in Claude Opus 4.7 harness profile.
+*
+* Layers a system-prompt suffix onto `anthropic:claude-opus-4-7`
+* tuned to the model's documented behaviors: parallel tool calls,
+* grounded answers, post-tool reflection, active investigation, and
+* subagent spawning guidance.
+*
+* @internal
+*/
+function register$3() {
+	registerHarnessProfileImpl("anthropic:claude-opus-4-7", createHarnessProfile({ systemPromptSuffix: SYSTEM_PROMPT_SUFFIX$3 }));
+}
+//#endregion
+//#region src/profiles/harness/builtins/anthropic-sonnet-4-6.ts
+const SYSTEM_PROMPT_SUFFIX$2 = `\
+<use_parallel_tool_calls>
+If you intend to call multiple tools and there are no dependencies between the tool calls, make all of the independent tool calls in parallel. Prioritize calling tools simultaneously whenever the actions can be done in parallel rather than sequentially. For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into context at the same time. Maximize use of parallel tool calls where possible to increase speed and efficiency. However, if some tool calls depend on previous calls to inform dependent values like the parameters, do NOT call these tools in parallel and instead call them sequentially. Never use placeholders or guess missing parameters in tool calls.
+</use_parallel_tool_calls>
+
+<investigate_before_answering>
+Never speculate about code you have not opened. If the user references a specific file, you MUST read the file before answering. Make sure to investigate and read relevant files BEFORE answering questions about the codebase. Never make any claims about code before investigating unless you are certain of the correct answer - give grounded and hallucination-free answers.
+</investigate_before_answering>
+
+<tool_result_reflection>
+After receiving tool results, carefully reflect on their quality and determine optimal next steps before proceeding. Use your thinking to plan and iterate based on this new information, and then take the best next action.
+</tool_result_reflection>`;
+/**
+* Register the built-in Claude Sonnet 4.6 harness profile.
+*
+* Layers universal Claude guidance (parallel tool calls, grounded
+* answers, post-tool reflection) onto `anthropic:claude-sonnet-4-6`.
+*
+* No Sonnet-specific overlays — Anthropic's guidance for Sonnet 4.6
+* centers on API-level configuration rather than system-prompt
+* adjustments. This module exists as the audit anchor: its presence
+* documents the review and justifies the absence of model-specific
+* content.
+*
+* @internal
+*/
+function register$2() {
+	registerHarnessProfileImpl("anthropic:claude-sonnet-4-6", createHarnessProfile({ systemPromptSuffix: SYSTEM_PROMPT_SUFFIX$2 }));
+}
+//#endregion
+//#region src/profiles/harness/builtins/anthropic-haiku-4-5.ts
+const SYSTEM_PROMPT_SUFFIX$1 = `\
+<use_parallel_tool_calls>
+If you intend to call multiple tools and there are no dependencies between the tool calls, make all of the independent tool calls in parallel. Prioritize calling tools simultaneously whenever the actions can be done in parallel rather than sequentially. For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into context at the same time. Maximize use of parallel tool calls where possible to increase speed and efficiency. However, if some tool calls depend on previous calls to inform dependent values like the parameters, do NOT call these tools in parallel and instead call them sequentially. Never use placeholders or guess missing parameters in tool calls.
+</use_parallel_tool_calls>
+
+<investigate_before_answering>
+Never speculate about code you have not opened. If the user references a specific file, you MUST read the file before answering. Make sure to investigate and read relevant files BEFORE answering questions about the codebase. Never make any claims about code before investigating unless you are certain of the correct answer - give grounded and hallucination-free answers.
+</investigate_before_answering>
+
+<tool_result_reflection>
+After receiving tool results, carefully reflect on their quality and determine optimal next steps before proceeding. Use your thinking to plan and iterate based on this new information, and then take the best next action.
+</tool_result_reflection>`;
+/**
+* Register the built-in Claude Haiku 4.5 harness profile.
+*
+* Same universal Claude guidance as Sonnet 4.6. No Haiku-specific
+* overlays.
+*
+* @internal
+*/
+function register$1() {
+	registerHarnessProfileImpl("anthropic:claude-haiku-4-5", createHarnessProfile({ systemPromptSuffix: SYSTEM_PROMPT_SUFFIX$1 }));
+}
+//#endregion
+//#region src/profiles/harness/builtins/openai-codex.ts
+/**
+* Model specs that receive the Codex harness profile.
+*
+* All variants share the same trained response style, so a single
+* suffix works across the family.
+*/
+const CODEX_MODEL_SPECS = [
+	"openai:gpt-5.1-codex",
+	"openai:gpt-5.2-codex",
+	"openai:gpt-5.3-codex"
+];
+const SYSTEM_PROMPT_SUFFIX = `\
+## Codex-Specific Behavior
+
+- You are an autonomous senior engineer. Once given a direction, proactively \
+gather context, plan, implement, and verify without waiting for additional \
+prompts at each step.
+- Persist until the task is fully handled end-to-end within the current turn \
+whenever feasible. Do not stop at analysis or partial fixes; carry changes \
+through implementation, verification, and a clear explanation of outcomes.
+- Bias to action: default to implementing with reasonable assumptions. Do not \
+end your turn with clarifications unless truly blocked.
+- Do not communicate an upfront plan or status preamble before acting. Just act.
+
+## Parallel Tool Use
+
+- Before any tool call, decide ALL files and resources you will need.
+- Batch reads, searches, and other independent operations into parallel tool \
+calls instead of issuing them one at a time.
+- Only make sequential calls when you truly cannot determine the next step \
+without seeing a prior result.
+
+## Plan Hygiene
+
+- Before finishing, reconcile every TODO or plan item created via write_todos. \
+Mark each as done, blocked (with a one-sentence reason), or cancelled. Do not \
+finish with pending items.`;
+/**
+* Register the built-in Codex harness profiles.
+*
+* Registers the same profile under each Codex model spec. Per-model
+* keys (not the bare `"openai"` prefix) keep the default behavior of
+* non-Codex OpenAI models unchanged.
+*
+* @internal
+*/
+function register() {
+	const profile = createHarnessProfile({ systemPromptSuffix: SYSTEM_PROMPT_SUFFIX });
+	for (const spec of CODEX_MODEL_SPECS) registerHarnessProfileImpl(spec, profile);
+}
+//#endregion
+//#region src/profiles/harness/builtins/index.ts
+/**
+* Register all built-in harness profiles and snapshot the resulting
+* registry keys as the builtin baseline.
+*
+* Called once during lazy bootstrap by `ensureBuiltinsLoaded()`.
+* Uses `registerHarnessProfileImpl` internally (not the public
+* `registerHarnessProfile`) to avoid triggering re-entrant bootstrap.
+*
+* @internal
+*/
+function loadBuiltinProfiles() {
+	register$3();
+	register$2();
+	register$1();
+	register();
+	snapshotBuiltinKeys();
+}
+//#endregion
+//#region src/profiles/harness/registry.ts
+/**
+* Process-global symbol key for the harness profile registry. The `.v1`
+* suffix is a version gate — bump it when the {@link HarnessProfileRegistry}
+* shape changes in a breaking way so that incompatible versions coexist
+* on `globalThis` without corrupting each other.
+*/
+const PROFILE_REGISTRY_KEY = Symbol.for("deepagents.harness-profiles.v1");
+/**
+* Returns the process-global registry, creating it on first access.
+*/
+function getHarnessProfileRegistry() {
+	const global = globalThis;
+	if (global[PROFILE_REGISTRY_KEY] == null) global[PROFILE_REGISTRY_KEY] = {
+		profiles: /* @__PURE__ */ new Map(),
+		builtinKeys: /* @__PURE__ */ new Set(),
+		builtinsLoaded: false
+	};
+	return global[PROFILE_REGISTRY_KEY];
+}
+/**
+* Ensure lazy-loaded builtin profiles have been registered.
+*
+* Called by the public `registerHarnessProfile` and lookup functions.
+* Built-in registration modules call `registerHarnessProfileImpl`
+* directly to avoid re-entrant bootstrap.
+*
+* @internal
+*/
+function ensureBuiltinsLoaded() {
+	const registry = getHarnessProfileRegistry();
+	if (registry.builtinsLoaded) return;
+	registry.builtinsLoaded = true;
+	loadBuiltinProfiles();
+}
+/**
+* Snapshot the current registry keys as the builtin baseline.
+*
+* Called by the builtin loader after all built-in profiles are
+* registered. This allows {@link hasUserRegisteredProfiles} to
+* distinguish user registrations from built-ins.
+*
+* @internal
+*/
+function snapshotBuiltinKeys() {
+	const registry = getHarnessProfileRegistry();
+	registry.builtinKeys = new Set(registry.profiles.keys());
+}
+/**
+* Core registration implementation. Does not trigger lazy bootstrap.
+*
+* Used by built-in profile modules during bootstrap. External callers
+* should use {@link registerHarnessProfile} instead.
+*
+* @internal
+*/
+function registerHarnessProfileImpl(key, profile) {
+	key = validateProfileKey(key);
+	const { profiles } = getHarnessProfileRegistry();
+	const existing = profiles.get(key);
+	if (existing !== void 0) profiles.set(key, mergeProfiles(existing, profile));
+	else profiles.set(key, profile);
+}
+/**
+* Register a harness profile for a provider or specific model.
+*
+* Accepts either a pre-built {@link HarnessProfile} (from
+* {@link createHarnessProfile}) or raw {@link HarnessProfileOptions}
+* that will be validated and frozen automatically.
+*
+* Registrations are **additive**: if a profile already exists under
+* `key`, the new profile is merged on top. The incoming profile's
+* fields win on scalar conflicts; set fields union; middleware
+* sequences merge by name.
+*
+* @param key - Either a bare provider (`"openai"`) for provider-wide
+*   defaults, or `"provider:model"` for a per-model override.
+* @param profile - A `HarnessProfile` or options to build one from.
+* @throws {Error} When `key` is malformed or profile validation
+*   fails.
+*
+* @example
+* ```typescript
+* import { registerHarnessProfile } from "@langchain/deepagents";
+*
+* registerHarnessProfile("openai", {
+*   systemPromptSuffix: "Respond concisely.",
+* });
+*
+* registerHarnessProfile("openai:gpt-5.4", {
+*   excludedTools: ["execute"],
+* });
+* ```
+*/
+function registerHarnessProfile(key, profile) {
+	ensureBuiltinsLoaded();
+	registerHarnessProfileImpl(key, isHarnessProfile(profile) ? profile : createHarnessProfile(profile));
+}
+/**
+* Look up the {@link HarnessProfile} for a model spec string.
+*
+* Resolution order:
+*
+* 1. **Exact match** on `spec` (e.g., `"openai:gpt-5.4"`).
+* 2. **Provider prefix** (everything before `:`) when `spec` contains
+*    a colon and both halves are non-empty.
+* 3. When both exist, they are **merged** (provider as base, exact as
+*    override).
+* 4. `undefined` when nothing matches.
+*
+* Malformed specs (empty, multiple colons, empty halves) return
+* `undefined` without consulting the registry.
+*
+* @param spec - Model spec in `"provider:model"` format, or a bare
+*   provider/model identifier.
+* @returns The matching profile, or `undefined`.
+*/
+function getHarnessProfile(spec) {
+	if (spec.split(":").length > 2) return;
+	const colonIdx = spec.indexOf(":");
+	const hasColon = colonIdx !== -1;
+	const provider = hasColon ? spec.slice(0, colonIdx) : void 0;
+	const model = hasColon ? spec.slice(colonIdx + 1) : void 0;
+	if (hasColon && (!provider || !model)) return;
+	ensureBuiltinsLoaded();
+	const { profiles } = getHarnessProfileRegistry();
+	const exact = profiles.get(spec);
+	const base = provider ? profiles.get(provider) : void 0;
+	if (exact !== void 0 && base !== void 0) return mergeProfiles(base, exact);
+	return exact ?? base;
+}
+/**
+* Resolve the harness profile for a model, falling back to the
+* empty default when nothing matches.
+*
+* When `spec` is set (the original model parameter), it drives the
+* lookup directly. When absent (pre-built model instance),
+* `providerHint` and `identifierHint` are used to construct lookup
+* keys.
+*
+* @param opts - Model metadata used to resolve the profile.
+* @returns The resolved profile (never `undefined`).
+*
+* @internal
+*/
+function resolveHarnessProfile(opts = {}) {
+	const { spec, providerHint, identifierHint } = opts;
+	if (spec !== void 0) return getHarnessProfile(spec) ?? EMPTY_HARNESS_PROFILE;
+	if (providerHint && identifierHint && !identifierHint.includes(":")) {
+		const profile = getHarnessProfile(`${providerHint}:${identifierHint}`);
+		if (profile) return profile;
+	}
+	if (identifierHint && identifierHint.includes(":")) {
+		const profile = getHarnessProfile(identifierHint);
+		if (profile) return profile;
+	}
+	if (providerHint) {
+		const profile = getHarnessProfile(providerHint);
+		if (profile) return profile;
+	}
+	return EMPTY_HARNESS_PROFILE;
+}
+/**
+* Apply a profile's prompt overlay to a base prompt string.
+*
+* - `baseSystemPrompt` (when set) replaces `basePrompt` entirely.
+* - `systemPromptSuffix` (when set) is appended with `\n\n`.
+*
+* Both are independently optional. A profile that sets only the suffix
+* layers it on top of whatever base the caller passes in.
+*
+* Used uniformly for the main agent, declarative subagents, and the
+* auto-added general-purpose subagent.
+*
+* @param profile - The harness profile to apply.
+* @param basePrompt - The default base prompt (e.g., `BASE_AGENT_PROMPT`).
+* @returns The assembled prompt string.
+*/
+function applyProfilePrompt(profile, basePrompt) {
+	const prompt = profile.baseSystemPrompt !== void 0 ? profile.baseSystemPrompt : basePrompt;
+	if (profile.systemPromptSuffix !== void 0) return `${prompt}\n\n${profile.systemPromptSuffix}`;
+	return prompt;
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Detect whether a model is an Anthropic model.
+*
+* Used to gate Anthropic-specific prompt caching optimizations
+* (cache_control breakpoints).
+*/
+function isAnthropicModel(model) {
+	if (typeof model === "string") {
+		if (model.includes(":")) return model.split(":")[0] === "anthropic";
+		return model.startsWith("claude");
+	}
+	if (model.getName() === "ConfigurableModel") return model._defaultConfig?.modelProvider === "anthropic";
+	return model.getName() === "ChatAnthropic";
+}
+/**
+* Extract the provider name from a model instance for profile lookup.
+*
+* Checks `_defaultConfig.modelProvider` (ConfigurableModel) and falls
+* back to known model class name → provider mappings.
+*
+* @internal
+*/
+function getModelProvider(model) {
+	if (model.getName() === "ConfigurableModel") return model._defaultConfig?.modelProvider;
+	return {
+		ChatAnthropic: "anthropic",
+		ChatOpenAI: "openai",
+		ChatGoogleGenerativeAI: "google"
+	}[model.getName()];
+}
+/**
+* Extract the model identifier from a model instance for profile
+* lookup.
+*
+* Checks `_defaultConfig.model`, `model_name`, and `modelName` in
+* that order.
+*
+* @internal
+*/
+function getModelIdentifier(model) {
+	return (model.getName() === "ConfigurableModel" ? model._defaultConfig : void 0)?.model ?? model.model_name ?? model.modelName ?? void 0;
+}
+//#endregion
 //#region src/agent.ts
 const BASE_AGENT_PROMPT = langchain.context`
   You are a Deep Agent, an AI assistant that helps users accomplish tasks using tools. You respond with text and tool calls. The user can see your responses and tool outputs in real time.
@@ -7002,18 +8091,6 @@ const BUILTIN_TOOL_NAMES = new Set([
 	"write_todos"
 ]);
 /**
-* Detect whether a model is an Anthropic model.
-* Used to gate Anthropic-specific prompt caching optimizations (cache_control breakpoints).
-*/
-function isAnthropicModel(model) {
-	if (typeof model === "string") {
-		if (model.includes(":")) return model.split(":")[0] === "anthropic";
-		return model.startsWith("claude");
-	}
-	if (model.getName() === "ConfigurableModel") return model._defaultConfig?.modelProvider === "anthropic";
-	return model.getName() === "ChatAnthropic";
-}
-/**
 * Create a Deep Agent.
 *
 * This is the main entry point for building a production-style agent with
@@ -7047,6 +8124,12 @@ function createDeepAgent(params = {}) {
 	const { model = "anthropic:claude-sonnet-4-6", tools = [], systemPrompt, middleware: customMiddleware = [], subagents = [], responseFormat, contextSchema, checkpointer, store, backend = (config) => new StateBackend(config), interruptOn, name, memory, skills, permissions = [], streamTransformers = [] } = params;
 	const collidingTools = tools.map((t) => t.name).filter((n) => typeof n === "string" && BUILTIN_TOOL_NAMES.has(n));
 	if (collidingTools.length > 0) throw new ConfigurationError(`Tool name(s) [${collidingTools.join(", ")}] conflict with built-in tools. Rename your custom tools to avoid this.`, "TOOL_NAME_COLLISION");
+	const harnessProfile = typeof model === "string" ? resolveHarnessProfile({ spec: model }) : resolveHarnessProfile({
+		providerHint: getModelProvider(model),
+		identifierHint: getModelIdentifier(model)
+	});
+	const toolOverrides = harnessProfile.toolDescriptionOverrides;
+	const effectiveTools = Object.keys(toolOverrides).length > 0 ? tools.map((t) => t.name in toolOverrides ? Object.assign(Object.create(Object.getPrototypeOf(t)), t, { description: toolOverrides[t.name] }) : t) : tools;
 	const anthropicModel = isAnthropicModel(model);
 	const cacheMiddleware = anthropicModel ? [(0, langchain.anthropicPromptCachingMiddleware)({
 		unsupportedModelBehavior: "ignore",
@@ -7085,12 +8168,16 @@ function createDeepAgent(params = {}) {
 	const allSubagents = subagents;
 	const asyncSubAgents = allSubagents.filter((item) => isAsyncSubAgent(item));
 	const inlineSubagents = allSubagents.filter((item) => !isAsyncSubAgent(item)).map((item) => "runnable" in item ? item : normalizeSubagentSpec(item));
-	if (!inlineSubagents.some((item) => item.name === GENERAL_PURPOSE_SUBAGENT["name"])) {
+	const gpConfig = harnessProfile.generalPurposeSubagent;
+	if (!(gpConfig?.enabled === false) && !inlineSubagents.some((item) => item.name === GENERAL_PURPOSE_SUBAGENT["name"])) {
+		const gpSystemPrompt = gpConfig?.systemPrompt ?? applyProfilePrompt(harnessProfile, GENERAL_PURPOSE_SUBAGENT.systemPrompt);
 		const generalPurposeSpec = normalizeSubagentSpec({
 			...GENERAL_PURPOSE_SUBAGENT,
+			description: gpConfig?.description ?? GENERAL_PURPOSE_SUBAGENT.description,
+			systemPrompt: gpSystemPrompt,
 			model,
 			skills,
-			tools
+			tools: effectiveTools
 		});
 		inlineSubagents.unshift(generalPurposeSpec);
 	}
@@ -7106,7 +8193,7 @@ function createDeepAgent(params = {}) {
 		}),
 		createSubAgentMiddleware({
 			defaultModel: model,
-			defaultTools: tools,
+			defaultTools: effectiveTools,
 			defaultInterruptOn: interruptOn,
 			subagents: inlineSubagents,
 			generalPurposeAgent: false
@@ -7131,6 +8218,31 @@ function createDeepAgent(params = {}) {
 		})] : [],
 		...interruptOn ? [(0, langchain.humanInTheLoopMiddleware)({ interruptOn })] : []
 	];
+	const profileMiddleware = resolveMiddleware(harnessProfile.extraMiddleware);
+	if (profileMiddleware.length > 0) {
+		const cacheIdx = middleware.findIndex((m) => m.name === "AnthropicPromptCachingMiddleware");
+		if (cacheIdx !== -1) middleware.splice(cacheIdx, 0, ...profileMiddleware);
+		else middleware.push(...profileMiddleware);
+	}
+	if (harnessProfile.excludedMiddleware.size > 0) {
+		const excluded = harnessProfile.excludedMiddleware;
+		const filtered = middleware.filter((m) => !excluded.has(m.name));
+		middleware.length = 0;
+		middleware.push(...filtered);
+	}
+	if (harnessProfile.excludedTools.size > 0) {
+		const excludedTools = harnessProfile.excludedTools;
+		middleware.push((0, langchain.createMiddleware)({
+			name: "_ToolExclusionMiddleware",
+			wrapModelCall: async (request, handler) => {
+				return handler({
+					...request,
+					tools: request.tools?.filter((t) => !excludedTools.has(t.name))
+				});
+			}
+		}));
+	}
+	const effectiveBasePrompt = applyProfilePrompt(harnessProfile, BASE_AGENT_PROMPT);
 	/**
 	* Return as DeepAgent with proper DeepAgentTypeConfig
 	* - Response: InferStructuredResponse<TResponse> (unwraps ToolStrategy<T>/ProviderStrategy<T> → T)
@@ -7148,15 +8260,15 @@ function createDeepAgent(params = {}) {
 			text: systemPrompt
 		}, {
 			type: "text",
-			text: BASE_AGENT_PROMPT
+			text: effectiveBasePrompt
 		}] }) : langchain.SystemMessage.isInstance(systemPrompt) ? new langchain.SystemMessage({ contentBlocks: [...systemPrompt.contentBlocks, {
 			type: "text",
-			text: BASE_AGENT_PROMPT
+			text: effectiveBasePrompt
 		}] }) : new langchain.SystemMessage({ contentBlocks: [{
 			type: "text",
-			text: BASE_AGENT_PROMPT
+			text: effectiveBasePrompt
 		}] }),
-		tools,
+		tools: effectiveTools,
 		middleware,
 		...responseFormat !== null && { responseFormat },
 		contextSchema,
@@ -7688,8 +8800,10 @@ function listSkills(options) {
 exports.BaseSandbox = BaseSandbox;
 exports.CompositeBackend = CompositeBackend;
 exports.ConfigurationError = ConfigurationError;
+exports.ContextHubBackend = ContextHubBackend;
 exports.DEFAULT_GENERAL_PURPOSE_DESCRIPTION = DEFAULT_GENERAL_PURPOSE_DESCRIPTION;
 exports.DEFAULT_SUBAGENT_PROMPT = DEFAULT_SUBAGENT_PROMPT;
+exports.EMPTY_HARNESS_PROFILE = EMPTY_HARNESS_PROFILE;
 exports.FilesystemBackend = FilesystemBackend;
 exports.GENERAL_PURPOSE_SUBAGENT = GENERAL_PURPOSE_SUBAGENT;
 exports.LangSmithSandbox = LangSmithSandbox;
@@ -7697,6 +8811,7 @@ exports.LocalShellBackend = LocalShellBackend;
 exports.MAX_SKILL_DESCRIPTION_LENGTH = MAX_SKILL_DESCRIPTION_LENGTH;
 exports.MAX_SKILL_FILE_SIZE = MAX_SKILL_FILE_SIZE;
 exports.MAX_SKILL_NAME_LENGTH = MAX_SKILL_NAME_LENGTH;
+exports.REQUIRED_MIDDLEWARE_NAMES = REQUIRED_MIDDLEWARE_NAMES;
 exports.SandboxError = SandboxError;
 exports.StateBackend = StateBackend;
 exports.StoreBackend = StoreBackend;
@@ -7709,6 +8824,7 @@ exports.createAsyncSubAgentMiddleware = createAsyncSubAgentMiddleware;
 exports.createCompletionCallbackMiddleware = createCompletionCallbackMiddleware;
 exports.createDeepAgent = createDeepAgent;
 exports.createFilesystemMiddleware = createFilesystemMiddleware;
+exports.createHarnessProfile = createHarnessProfile;
 exports.createMemoryMiddleware = createMemoryMiddleware;
 exports.createPatchToolCallsMiddleware = createPatchToolCallsMiddleware;
 exports.createSettings = createSettings;
@@ -7718,11 +8834,17 @@ exports.createSubagentTransformer = createSubagentTransformer;
 exports.createSummarizationMiddleware = createSummarizationMiddleware;
 exports.filesValue = filesValue;
 exports.findProjectRoot = findProjectRoot;
+exports.generalPurposeSubagentConfigSchema = generalPurposeSubagentConfigSchema;
+exports.getHarnessProfile = getHarnessProfile;
+exports.harnessProfileConfigSchema = harnessProfileConfigSchema;
 exports.isAsyncSubAgent = isAsyncSubAgent;
 exports.isSandboxBackend = isSandboxBackend;
 exports.isSandboxProtocol = isSandboxProtocol;
 exports.listSkills = listSkills;
+exports.parseHarnessProfileConfig = parseHarnessProfileConfig;
 exports.parseSkillMetadata = parseSkillMetadata;
+exports.registerHarnessProfile = registerHarnessProfile;
 exports.resolveBackend = resolveBackend;
+exports.serializeProfile = serializeProfile;
 
 //# sourceMappingURL=index.cjs.map