deepagents 1.13.5 → 1.14.0

package/dist/{langsmith-CG8px69t.cjs → langsmith-C9zNPKIz.cjs}

@@ -3620,6 +3620,11 @@ const EXCLUDED_STATE_KEYS = [
 * the parent's private channels (skills metadata, memory contents, etc.)
 * to rebuild an equivalent prompt.
 *
+* A pending invalidation propagates: a fork spawned in the same iteration
+* that set `skillsMetadata` to `null` inherits the `null`, so its mirrored
+* skills middleware reloads from its own sources rather than seeing the
+* parent's last loaded list.
+*
 * Call counts stay excluded: a fork inherits the parent's middleware, so
 * sharing them collides on the parent's channel.
 */
@@ -4584,30 +4589,37 @@ const SkillMetadataEntrySchema = zod.z.object({
 	module: zod.z.string().optional()
 });
 /**
-* Reducer for skillsMetadata that merges arrays from parallel subagents.
-* Skills are deduplicated by name, with later values overriding earlier ones.
+* State value for a middleware's `skillsMetadata` field.
+*
+* A middleware can only read and write the fields declared on its own state
+* schema. A middleware that needs `skillsMetadata` — to inspect the skills
+* loaded for the thread, or to set the field to `null` and make the next model
+* call reload every source — declares it with this value.
+*
+* Treat the value as opaque: it is meant to be passed to `StateSchema`, and
+* its concrete type is an implementation detail that may change. To type an
+* individual entry, use {@link SkillMetadataEntry}.
+*
+* @example
+* ```typescript
+* import { createMiddleware } from "langchain";
+* import { StateSchema } from "@langchain/langgraph";
+* import { skillsMetadataValue } from "deepagents";
 *
-* @param current - The current skillsMetadata array (from state)
-* @param update - The new skillsMetadata array (from a subagent update)
-* @returns Merged array with duplicates resolved by name (later values win)
+* const reloadEditedSkills = createMiddleware({
+*   name: "ReloadEditedSkills",
+*   stateSchema: new StateSchema({ skillsMetadata: skillsMetadataValue }),
+*   afterAgent: (state) =>
+*     agentEditedSkills(state) ? { skillsMetadata: null } : undefined,
+* });
+* ```
 */
-function skillsMetadataReducer(current, update) {
-	if (!update || update.length === 0) return current || [];
-	if (!current || current.length === 0) return update;
-	const merged = /* @__PURE__ */ new Map();
-	for (const skill of current) merged.set(skill.name, skill);
-	for (const skill of update) merged.set(skill.name, skill);
-	return Array.from(merged.values());
-}
+const skillsMetadataValue = zod.z.array(SkillMetadataEntrySchema).nullish();
 /**
 * State schema for skills middleware.
-* Uses ReducedValue for skillsMetadata to allow concurrent updates from parallel subagents.
 */
 const SkillsStateSchema = new _langchain_langgraph.StateSchema({
-	skillsMetadata: new _langchain_langgraph.ReducedValue(zod.z.array(SkillMetadataEntrySchema).default(() => []), {
-		inputSchema: zod.z.array(SkillMetadataEntrySchema).optional(),
-		reducer: skillsMetadataReducer
-	}),
+	skillsMetadata: skillsMetadataValue,
 	files: filesValue
 });
 /**
@@ -4944,6 +4956,21 @@ function validateModulePath(raw) {
 * pattern: skill names and descriptions are shown in the prompt, but the agent
 * reads full SKILL.md content only when needed.
 *
+* Skills are loaded once per thread and stored in state. To pick up skills
+* added, edited, or deleted since then, set `skillsMetadata` to `null`; the
+* next model call reloads every source:
+*
+* ```ts
+* await agent.updateState(config, { skillsMetadata: null });
+* // or as part of the next run's input
+* await agent.invoke({ messages, skillsMetadata: null }, config);
+* ```
+*
+* Loading happens in `beforeModel`, so the reload is served by the next model
+* call rather than the next run. A middleware of your own can therefore
+* invalidate from any hook — including mid-run, from `afterModel` — and see
+* the fresh list on the following call. See {@link skillsMetadataValue}.
+*
 * @param options - Configuration options
 * @returns AgentMiddleware for skills loading and injection
 *
@@ -4960,8 +4987,8 @@ function createSkillsMiddleware(options) {
 	return (0, langchain.createMiddleware)({
 		name: "SkillsMiddleware",
 		stateSchema: SkillsStateSchema,
-		async beforeAgent(state) {
-			if ("skillsMetadata" in state && Array.isArray(state.skillsMetadata) && state.skillsMetadata.length > 0) return;
+		async beforeModel(state) {
+			if (state.skillsMetadata !== null && state.skillsMetadata !== void 0) return;
 			const resolvedBackend = await resolveBackend(backend, { state });
 			const allSkills = /* @__PURE__ */ new Map();
 			for (const sourcePath of sources) try {
@@ -9193,5 +9220,11 @@ Object.defineProperty(exports, "serializeProfile", {
 		return serializeProfile;
 	}
 });
+Object.defineProperty(exports, "skillsMetadataValue", {
+	enumerable: true,
+	get: function() {
+		return skillsMetadataValue;
+	}
+});
 
-//# sourceMappingURL=langsmith-CG8px69t.cjs.map
+//# sourceMappingURL=langsmith-C9zNPKIz.cjs.map