fix: missing files/memoryContents in memory middleware (#159)

* Update memory state schmea

* Update tests

* Update testing

* changeset

* Update libs/deepagents/src/middleware/memory.test.ts

* Update libs/deepagents/src/middleware/memory.test.ts

* Update libs/deepagents/src/middleware/memory.test.ts

* Update libs/deepagents/src/middleware/memory.test.ts

* Update libs/deepagents/src/middleware/memory.test.ts

* Update libs/deepagents/src/middleware/memory.test.ts

---------

Co-authored-by: Christian Bromann <git@bromann.dev>

Author: maahir30

.changeset/memory-statebackend-tests.md

@@ -0,0 +1,9 @@
+---
+"deepagents": patch
+---
+
+fix(deepagents): fix memoryMiddleware for statebacken
+- Export FileDataSchema for reuse.
+- Add files to MemoryStateSchema via StateSchema/ReducedValue.
+- Add StateBackend memory tests mirroring skills flow.
+

libs/deepagents/src/middleware/fs.ts

@@ -131,7 +131,7 @@ import type * as _messages from "@langchain/core/messages";
 /**
  * Zod v3 schema for FileData (re-export from backends)
  */
-const FileDataSchema = z.object({
+export const FileDataSchema = z.object({
   content: z.array(z.string()),
   created_at: z.string(),
   modified_at: z.string(),

libs/deepagents/src/middleware/memory.test.ts

@@ -4,6 +4,15 @@ import type {
   BackendProtocol,
   FileDownloadResponse,
 } from "../backends/protocol.js";
+import { createDeepAgent } from "../agent.js";
+import { FakeListChatModel } from "@langchain/core/utils/testing";
+import {
+  HumanMessage,
+  SystemMessage,
+  type BaseMessage,
+} from "@langchain/core/messages";
+import { MemorySaver } from "@langchain/langgraph";
+import { createFileData } from "../backends/utils.js";
 
 // Mock backend that returns specified files
 function createMockBackend(
@@ -261,3 +270,226 @@ describe("createMemoryMiddleware", () => {
     });
   });
 });
+
+/**
+ * StateBackend integration tests.
+ *
+ * These tests verify that memory is properly loaded from state.files and
+ * injected into the system prompt when using createDeepAgent with StateBackend.
+ */
+describe("StateBackend integration with createDeepAgent", () => {
+  const USER_MEMORY = `# User Memory
+
+Remember: The secret code is ALPHA123.`;
+
+  const PROJECT_MEMORY = `# Project Memory
+
+This project uses React.`;
+
+  /**
+   * Helper to extract system prompt content from model invoke spy.
+   * The system message can have content as string or array of content blocks.
+   */
+  function getSystemPromptFromSpy(
+    invokeSpy: ReturnType<typeof vi.spyOn>,
+  ): string {
+    const lastCall = invokeSpy.mock.calls[invokeSpy.mock.calls.length - 1];
+    const messages = lastCall?.[0] as BaseMessage[] | undefined;
+    if (!messages) return "";
+    const systemMessage = messages.find(SystemMessage.isInstance);
+    if (!systemMessage) return "";
+    return systemMessage.text;
+  }
+
+  it("should load memory from state.files and inject into system prompt", async () => {
+    const invokeSpy = vi.spyOn(FakeListChatModel.prototype, "invoke");
+    const model = new FakeListChatModel({ responses: ["Done"] });
+    const checkpointer = new MemorySaver();
+
+    const agent = createDeepAgent({
+      model: model as any,
+      memory: ["/AGENTS.md"],
+      checkpointer,
+    });
+
+    await agent.invoke(
+      {
+        messages: [new HumanMessage("What do you remember?")],
+        files: {
+          "/AGENTS.md": createFileData(USER_MEMORY),
+        },
+      },
+      {
+        configurable: { thread_id: `test-memory-${Date.now()}` },
+        recursionLimit: 50,
+      },
+    );
+
+    expect(invokeSpy).toHaveBeenCalled();
+    const systemPrompt = getSystemPromptFromSpy(invokeSpy);
+
+    expect(systemPrompt).toContain("ALPHA123");
+    expect(systemPrompt).toContain("/AGENTS.md");
+    invokeSpy.mockRestore();
+  });
+
+  it("should load multiple memory files from state.files", async () => {
+    const invokeSpy = vi.spyOn(FakeListChatModel.prototype, "invoke");
+    const model = new FakeListChatModel({ responses: ["Done"] });
+    const checkpointer = new MemorySaver();
+
+    const agent = createDeepAgent({
+      model: model as any,
+      memory: ["/user/AGENTS.md", "/project/AGENTS.md"],
+      checkpointer,
+    });
+
+    await agent.invoke(
+      {
+        messages: [new HumanMessage("List all memory")],
+        files: {
+          "/user/AGENTS.md": createFileData(USER_MEMORY),
+          "/project/AGENTS.md": createFileData(PROJECT_MEMORY),
+        },
+      },
+      {
+        configurable: { thread_id: `test-memory-multi-${Date.now()}` },
+        recursionLimit: 50,
+      },
+    );
+
+    expect(invokeSpy).toHaveBeenCalled();
+    const systemPrompt = getSystemPromptFromSpy(invokeSpy);
+
+    expect(systemPrompt).toContain("ALPHA123");
+    expect(systemPrompt).toContain("This project uses React.");
+    invokeSpy.mockRestore();
+  });
+
+  it("should show no memory message when state.files is empty", async () => {
+    const invokeSpy = vi.spyOn(FakeListChatModel.prototype, "invoke");
+    const model = new FakeListChatModel({ responses: ["Done"] });
+    const checkpointer = new MemorySaver();
+
+    const agent = createDeepAgent({
+      model: model as any,
+      memory: ["/AGENTS.md"],
+      checkpointer,
+    });
+
+    await agent.invoke(
+      {
+        messages: [new HumanMessage("Hello")],
+        files: {},
+      },
+      {
+        configurable: { thread_id: `test-memory-empty-${Date.now()}` },
+        recursionLimit: 50,
+      },
+    );
+
+    expect(invokeSpy).toHaveBeenCalled();
+    const systemPrompt = getSystemPromptFromSpy(invokeSpy);
+
+    expect(systemPrompt).toContain("(No memory loaded)");
+    invokeSpy.mockRestore();
+  });
+
+  it("should load memory from multiple sources via StateBackend", async () => {
+    const invokeSpy = vi.spyOn(FakeListChatModel.prototype, "invoke");
+    const model = new FakeListChatModel({ responses: ["Done"] });
+    const checkpointer = new MemorySaver();
+
+    const agent = createDeepAgent({
+      model: model as any,
+      memory: ["/memory/user/AGENTS.md", "/memory/project/AGENTS.md"],
+      checkpointer,
+    });
+
+    await agent.invoke(
+      {
+        messages: [new HumanMessage("List memory")],
+        files: {
+          "/memory/user/AGENTS.md": createFileData(USER_MEMORY),
+          "/memory/project/AGENTS.md": createFileData(PROJECT_MEMORY),
+        },
+      },
+      {
+        configurable: { thread_id: `test-memory-sources-${Date.now()}` },
+        recursionLimit: 50,
+      },
+    );
+
+    expect(invokeSpy).toHaveBeenCalled();
+    const systemPrompt = getSystemPromptFromSpy(invokeSpy);
+
+    expect(systemPrompt).toContain("/memory/user/AGENTS.md");
+    expect(systemPrompt).toContain("/memory/project/AGENTS.md");
+    invokeSpy.mockRestore();
+  });
+
+  it("should include memory paths in the system prompt", async () => {
+    const invokeSpy = vi.spyOn(FakeListChatModel.prototype, "invoke");
+    const model = new FakeListChatModel({ responses: ["Done"] });
+    const checkpointer = new MemorySaver();
+
+    const agent = createDeepAgent({
+      model: model as any,
+      memory: ["/AGENTS.md"],
+      checkpointer,
+    });
+
+    await agent.invoke(
+      {
+        messages: [new HumanMessage("What memory do you have?")],
+        files: {
+          "/AGENTS.md": createFileData(USER_MEMORY),
+        },
+      },
+      {
+        configurable: { thread_id: `test-memory-paths-${Date.now()}` },
+        recursionLimit: 50,
+      },
+    );
+
+    expect(invokeSpy).toHaveBeenCalled();
+    const systemPrompt = getSystemPromptFromSpy(invokeSpy);
+
+    expect(systemPrompt).toContain("/AGENTS.md");
+    expect(systemPrompt).toContain("<memory_guidelines>");
+    invokeSpy.mockRestore();
+  });
+
+  it("should handle empty memory directory gracefully", async () => {
+    const invokeSpy = vi.spyOn(FakeListChatModel.prototype, "invoke");
+    const model = new FakeListChatModel({ responses: ["Done"] });
+    const checkpointer = new MemorySaver();
+
+    const agent = createDeepAgent({
+      model: model as any,
+      memory: ["/memory/empty/AGENTS.md"],
+      checkpointer,
+    });
+
+    await expect(
+      agent.invoke(
+        {
+          messages: [new HumanMessage("Hello")],
+          files: {},
+        },
+        {
+          configurable: {
+            thread_id: `test-memory-empty-graceful-${Date.now()}`,
+          },
+          recursionLimit: 50,
+        },
+      ),
+    ).resolves.toBeDefined();
+
+    expect(invokeSpy).toHaveBeenCalled();
+    const systemPrompt = getSystemPromptFromSpy(invokeSpy);
+
+    expect(systemPrompt).toContain("(No memory loaded)");
+    invokeSpy.mockRestore();
+  });
+});

libs/deepagents/src/middleware/memory.ts

@@ -60,6 +60,8 @@ import {
 import type { BackendProtocol, BackendFactory } from "../backends/protocol.js";
 import type { StateBackend } from "../backends/state.js";
 import type { BaseStore } from "@langchain/langgraph-checkpoint";
+import { fileDataReducer, FileDataSchema } from "./fs.js";
+import { ReducedValue, StateSchema } from "@langchain/langgraph";
 
 /**
  * Options for the memory middleware.
@@ -85,12 +87,19 @@ export interface MemoryMiddlewareOptions {
 /**
  * State schema for memory middleware.
  */
-const MemoryStateSchema = z.object({
+const MemoryStateSchema = new StateSchema({
   /**
    * Dict mapping source paths to their loaded content.
    * Marked as private so it's not included in the final agent state.
    */
   memoryContents: z.record(z.string(), z.string()).optional(),
+  files: new ReducedValue(
+    z.record(z.string(), FileDataSchema).default(() => ({})),
+    {
+      inputSchema: z.record(z.string(), FileDataSchema.nullable()).optional(),
+      reducer: fileDataReducer,
+    },
+  ),
 });
 
 /**