chore(deepagents): update deps and re-establish old interfaces (#133)

* chore(deepagents): update deps

* add changeset

* re-estebalish old interfaces

* format

* skip new integration test for now

Author: christian-bromann

.changeset/some-otters-own.md

@@ -0,0 +1,5 @@
+---
+"deepagents": patch
+---
+
+chore(deepagents): update deps

libs/deepagents/package.json

@@ -38,31 +38,31 @@
   },
   "homepage": "https://github.com/langchain-ai/deepagentsjs#readme",
   "dependencies": {
-    "@langchain/anthropic": "^1.3.7",
-    "@langchain/core": "^1.1.12",
-    "@langchain/langgraph": "^1.0.14",
+    "@langchain/anthropic": "^1.3.11",
+    "@langchain/core": "^1.1.16",
+    "@langchain/langgraph": "^1.1.1",
     "fast-glob": "^3.3.3",
-    "langchain": "^1.2.7",
+    "langchain": "^1.2.12",
     "micromatch": "^4.0.8",
     "yaml": "^2.8.2",
     "zod": "^4.3.5"
   },
   "devDependencies": {
     "@langchain/langgraph-checkpoint": "^1.0.0",
-    "@langchain/openai": "^1.2.1",
+    "@langchain/openai": "^1.2.3",
     "@langchain/tavily": "^1.2.0",
     "@tsconfig/recommended": "^1.0.13",
     "@types/micromatch": "^4.0.10",
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.0.9",
     "@types/uuid": "^11.0.0",
-    "@vitest/coverage-v8": "^4.0.16",
-    "@vitest/ui": "^4.0.16",
+    "@vitest/coverage-v8": "^4.0.17",
+    "@vitest/ui": "^4.0.17",
     "dotenv": "^17.2.3",
     "tsdown": "^0.19.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "uuid": "^13.0.0",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.17"
   },
   "exports": {
     ".": {

libs/deepagents/src/backends/composite.ts

@@ -6,6 +6,7 @@ import type {
   BackendProtocol,
   EditResult,
   ExecuteResponse,
+  FileData,
   FileDownloadResponse,
   FileInfo,
   FileUploadResponse,
@@ -132,6 +133,17 @@ export class CompositeBackend implements BackendProtocol {
     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: string): Promise<FileData> {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.readRaw(strippedKey);
+  }
+
   /**
    * Structured search results or error string for invalid input.
    */
@@ -304,6 +316,10 @@ export class CompositeBackend implements BackendProtocol {
     }
 
     for (const [backend, batch] of batchesByBackend) {
+      if (!backend.uploadFiles) {
+        throw new Error("Backend does not support uploadFiles");
+      }
+
       const batchFiles = batch.map(
         (b) => [b.path, b.content] as [string, Uint8Array],
       );
@@ -347,6 +363,10 @@ export class CompositeBackend implements BackendProtocol {
     }
 
     for (const [backend, batch] of batchesByBackend) {
+      if (!backend.downloadFiles) {
+        throw new Error("Backend does not support downloadFiles");
+      }
+
       const batchPaths = batch.map((b) => b.path);
       const batchResponses = await backend.downloadFiles(batchPaths);
 

libs/deepagents/src/backends/filesystem.ts

@@ -18,6 +18,7 @@ import micromatch from "micromatch";
 import type {
   BackendProtocol,
   EditResult,
+  FileData,
   FileDownloadResponse,
   FileInfo,
   FileUploadResponse,
@@ -244,6 +245,46 @@ export class FilesystemBackend implements BackendProtocol {
     }
   }
 
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  async readRaw(filePath: string): Promise<FileData> {
+    const resolvedPath = this.resolvePath(filePath);
+
+    let content: string;
+    let stat: fsSync.Stats;
+
+    if (SUPPORTS_NOFOLLOW) {
+      stat = await fs.stat(resolvedPath);
+      if (!stat.isFile()) throw new Error(`File '${filePath}' not found`);
+      const fd = await fs.open(
+        resolvedPath,
+        fsSync.constants.O_RDONLY | fsSync.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.

libs/deepagents/src/backends/protocol.ts

@@ -174,6 +174,14 @@ export interface BackendProtocol {
    */
   read(filePath: string, offset?: number, limit?: number): MaybePromise<string>;
 
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  readRaw(filePath: string): MaybePromise<FileData>;
+
   /**
    * Structured search results or error string for invalid input.
    *
@@ -226,21 +234,23 @@ export interface BackendProtocol {
 
   /**
    * Upload multiple files.
+   * Optional - backends that don't support file upload can omit this.
    *
    * @param files - List of [path, content] tuples to upload
    * @returns List of FileUploadResponse objects, one per input file
    */
-  uploadFiles(
+  uploadFiles?(
     files: Array<[string, Uint8Array]>,
   ): MaybePromise<FileUploadResponse[]>;
 
   /**
    * Download multiple files.
+   * Optional - backends that don't support file download can omit this.
    *
    * @param paths - List of file paths to download
    * @returns List of FileDownloadResponse objects, one per input path
    */
-  downloadFiles(paths: string[]): MaybePromise<FileDownloadResponse[]>;
+  downloadFiles?(paths: string[]): MaybePromise<FileDownloadResponse[]>;
 }
 
 /**

libs/deepagents/src/backends/sandbox.ts

@@ -11,6 +11,7 @@
 import type {
   EditResult,
   ExecuteResponse,
+  FileData,
   FileDownloadResponse,
   FileInfo,
   FileUploadResponse,
@@ -394,6 +395,38 @@ export abstract class BaseSandbox implements SandboxBackendProtocol {
     return result.output;
   }
 
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  async readRaw(filePath: string): Promise<FileData> {
+    const command = buildReadCommand(filePath, 0, Number.MAX_SAFE_INTEGER);
+    const result = await this.execute(command);
+
+    if (result.exitCode !== 0) {
+      throw new Error(`File '${filePath}' not found`);
+    }
+
+    // Parse the line-numbered output back to content
+    const lines: string[] = [];
+    for (const line of result.output.split("\n")) {
+      // Format is "    123\tContent"
+      const tabIndex = line.indexOf("\t");
+      if (tabIndex !== -1) {
+        lines.push(line.substring(tabIndex + 1));
+      }
+    }
+
+    const now = new Date().toISOString();
+    return {
+      content: lines,
+      created_at: now,
+      modified_at: now,
+    };
+  }
+
   /**
    * Structured search results or error string for invalid input.
    */

libs/deepagents/src/backends/state.ts

@@ -126,6 +126,20 @@ export class StateBackend implements BackendProtocol {
     return formatReadResponse(fileData, offset, limit);
   }
 
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  readRaw(filePath: string): FileData {
+    const files = this.getFiles();
+    const fileData = files[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.

libs/deepagents/src/backends/store.ts

@@ -241,21 +241,28 @@ export class StoreBackend implements BackendProtocol {
     limit: number = 500,
   ): Promise<string> {
     try {
-      const store = this.getStore();
-      const namespace = this.getNamespace();
-      const item = await store.get(namespace, filePath);
-
-      if (!item) {
-        return `Error: File '${filePath}' not found`;
-      }
-
-      const fileData = this.convertStoreItemToFileData(item);
+      const fileData = await this.readRaw(filePath);
       return formatReadResponse(fileData, offset, limit);
     } catch (e: any) {
       return `Error: ${e.message}`;
     }
   }
 
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  async readRaw(filePath: string): Promise<FileData> {
+    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.

libs/deepagents/src/middleware/hitl.int.test.ts

@@ -254,4 +254,78 @@ describe("Human-in-the-Loop (HITL) Integration Tests", () => {
       expect(result.messages.length).toBeGreaterThan(0);
     },
   );
+
+  it.concurrent(
+    "should properly propagate HITL interrupts from subagents without TypeError",
+    { timeout: 120000 },
+    async () => {
+      // This test specifically verifies the fix for the issue where
+      // GraphInterrupt.interrupts was undefined when propagating from subagents,
+      // causing "Cannot read properties of undefined (reading 'length')" error
+
+      const checkpointer = new MemorySaver();
+      const agent = createDeepAgent({
+        tools: [sampleTool],
+        interruptOn: { sample_tool: true },
+        checkpointer,
+      });
+
+      const config = { configurable: { thread_id: uuidv4() } };
+
+      // Invoke with a task that will use the subagent which has HITL
+      // The subagent should interrupt, and this interrupt should propagate
+      // properly to the parent graph without causing a TypeError
+      const result = await agent.invoke(
+        {
+          messages: [
+            new HumanMessage(
+              "Use the task tool with the general-purpose subagent to call the sample_tool",
+            ),
+          ],
+        },
+        config,
+      );
+
+      // Verify the agent called the task tool
+      const aiMessages = result.messages.filter((msg: any) =>
+        AIMessage.isInstance(msg),
+      );
+      const toolCalls = aiMessages.flatMap((msg: any) => msg.tool_calls || []);
+      expect(toolCalls.some((tc: any) => tc.name === "task")).toBe(true);
+
+      // Verify interrupt was properly propagated from the subagent
+      expect(result.__interrupt__).toBeDefined();
+      expect(result.__interrupt__).toHaveLength(1);
+
+      // Verify the interrupt has the correct HITL structure
+      const interrupt = result.__interrupt__?.[0];
+      expect(interrupt).toBeDefined();
+      expect(interrupt!.value).toBeDefined();
+
+      const hitlRequest = interrupt!.value as HITLRequest;
+      expect(hitlRequest.actionRequests).toBeDefined();
+      expect(hitlRequest.actionRequests.length).toBeGreaterThan(0);
+      expect(hitlRequest.reviewConfigs).toBeDefined();
+      expect(hitlRequest.reviewConfigs.length).toBeGreaterThan(0);
+
+      // Verify we can resume successfully
+      const resumeResult = await agent.invoke(
+        new Command({
+          resume: {
+            decisions: [{ type: "approve" }],
+          },
+        }),
+        config,
+      );
+
+      // After resume, there should be no more interrupts
+      expect(resumeResult.__interrupt__).toBeUndefined();
+
+      // The tool should have been executed
+      const toolMessages = resumeResult.messages.filter(
+        (msg: any) => msg._getType() === "tool",
+      );
+      expect(toolMessages.length).toBeGreaterThan(0);
+    },
+  );
 });

libs/deepagents/src/middleware/memory.ts

@@ -194,6 +194,15 @@ async function loadMemoryFromBackend(
   backend: BackendProtocol,
   path: string,
 ): Promise<string | null> {
+  // Use downloadFiles if available, otherwise fall back to read
+  if (!backend.downloadFiles) {
+    const content = await backend.read(path);
+    if (content.startsWith("Error:")) {
+      return null;
+    }
+    return content;
+  }
+
   const results = await backend.downloadFiles([path]);
 
   // Should get exactly one response for one path