deepagents 1.8.8 → 1.9.0-alpha.1

package/dist/index.d.ts

@@ -1,23 +1,225 @@
 import * as _langchain from "langchain";
-import { AgentMiddleware, AgentMiddleware as AgentMiddleware$1, AgentTypeConfig, CreateAgentParams, HumanMessage, InferMiddlewareStates, InterruptOnConfig, ProviderStrategy, ReactAgent, ResponseFormat, ResponseFormatUndefined, Runtime, StructuredTool, SystemMessage, ToolMessage, ToolStrategy } from "langchain";
-import { Runnable } from "@langchain/core/runnables";
+import { AgentMiddleware, AgentMiddleware as AgentMiddleware$1, AgentTypeConfig, CreateAgentParams, HumanMessage, InferMiddlewareStates, InterruptOnConfig, ProviderStrategy, ReactAgent, ResponseFormat, ResponseFormatUndefined, Runtime, StructuredTool, SystemMessage, ToolMessage, ToolRuntime, ToolStrategy } from "langchain";
 import * as _langgraph from "@langchain/langgraph";
 import { AnnotationRoot, Command, ReducedValue, StateSchema } from "@langchain/langgraph";
 import { z } from "zod/v4";
 import * as _messages from "@langchain/core/messages";
-import * as zod from "zod";
+import * as z$2 from "zod";
 import { z as z$1 } from "zod";
+import { Client } from "@langchain/langgraph-sdk";
 import { CreateSandboxOptions, Sandbox } from "langsmith/experimental/sandbox";
-import * as zod_v30 from "zod/v3";
-import * as _langchain_core_tools0 from "@langchain/core/tools";
-import { ClientTool, ServerTool, StructuredTool as StructuredTool$1, ToolRuntime } from "@langchain/core/tools";
+import * as _$zod_v30 from "zod/v3";
 import { BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
-import * as zod_v4_core0 from "zod/v4/core";
+import * as _$zod_v4_core0 from "zod/v4/core";
+import * as _$_langchain_core_tools0 from "@langchain/core/tools";
+import { ClientTool, ServerTool, StructuredTool as StructuredTool$1 } from "@langchain/core/tools";
+import { InteropZodObject } from "@langchain/core/utils/types";
 import { BaseLanguageModel, LanguageModelLike } from "@langchain/core/language_models/base";
+import { Runnable } from "@langchain/core/runnables";
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { InteropZodObject } from "@langchain/core/utils/types";
 
+//#region src/backends/v1/protocol.d.ts
+/**
+ * Protocol for pluggable memory backends (single, unified).
+ *
+ * Backends can store files in different locations (state, filesystem, database, etc.)
+ * and provide a uniform interface for file operations.
+ *
+ * All file data is represented as objects with the FileData structure.
+ *
+ * Methods can return either direct values or Promises, allowing both
+ * synchronous and asynchronous implementations.
+ *
+ * @deprecated Use {@link BackendProtocolV2} instead.
+ */
+interface BackendProtocolV1 {
+  /**
+   * Structured listing with file metadata.
+   *
+   * Lists files and directories in the specified directory (non-recursive).
+   * Directories have a trailing / in their path and is_dir=true.
+   *
+   * @param path - Absolute path to directory
+   * @returns List of FileInfo objects for files and directories directly in the directory
+   */
+  lsInfo(path: string): MaybePromise<FileInfo[]>;
+  /**
+   * Read file content.
+   *
+   * @param filePath - Absolute file path
+   * @param offset - Line offset to start reading from (0-indexed), default 0
+   * @param limit - Maximum number of lines to read, default 500
+   * @returns File content as plain string on success or error on failure
+   */
+  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>;
+  /**
+   * Search file contents for a literal text pattern.
+   *
+   * Binary files (determined by MIME type) are skipped.
+   *
+   * @param pattern - Literal text pattern to search for
+   * @param path - Base path to search from (default: null)
+   * @param glob - Optional glob pattern to filter files (e.g., "*.py")
+   * @returns Array of GrepMatch on success or error string on failure
+   */
+  grepRaw(pattern: string, path?: string | null, glob?: string | null): MaybePromise<GrepMatch[] | string>;
+  /**
+   * Structured glob matching returning FileInfo objects.
+   *
+   * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
+   * @param path - Base path to search from (default: "/")
+   * @returns List of FileInfo objects matching the pattern
+   */
+  globInfo(pattern: string, path?: string): MaybePromise<FileInfo[]>;
+  /**
+   * Create a new file.
+   *
+   * @param filePath - Absolute file path
+   * @param content - File content as string
+   * @returns WriteResult with error populated on failure
+   */
+  write(filePath: string, content: string): MaybePromise<WriteResult>;
+  /**
+   * Edit a file by replacing string occurrences.
+   *
+   * @param filePath - Absolute file path
+   * @param oldString - String to find and replace
+   * @param newString - Replacement string
+   * @param replaceAll - If true, replace all occurrences (default: false)
+   * @returns EditResult with error, path, filesUpdate, and occurrences
+   */
+  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): MaybePromise<EditResult>;
+  /**
+   * 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?(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[]>;
+}
+/**
+ * Protocol for sandboxed backends with isolated runtime.
+ * Sandboxed backends run in isolated environments (e.g., containers)
+ * and communicate via defined interfaces.
+ *
+ * @deprecated Use {@link SandboxBackendProtocolV2} instead.
+ */
+interface SandboxBackendProtocolV1 extends BackendProtocolV1 {
+  /**
+   * Execute a command in the sandbox.
+   *
+   * @param command - Full shell command string to execute
+   * @returns ExecuteResponse with combined output, exit code, and truncation flag
+   */
+  execute(command: string): MaybePromise<ExecuteResponse>;
+  /** Unique identifier for the sandbox backend instance */
+  readonly id: string;
+}
+//#endregion
+//#region src/backends/v2/protocol.d.ts
+/**
+ * Updated protocol for pluggable memory backends.
+ *
+ * Key differences from {@link BackendProtocol}:
+ * - `read()` returns {@link ReadResult} instead of a plain string
+ * - `readRaw()` returns {@link ReadRawResult} instead of FileData
+ * - `grep()` returns {@link GrepResult} instead of `GrepMatch[] | string`
+ * - `ls()` returns {@link LsResult} instead of FileInfo[]
+ * - `glob()` returns {@link GlobResult} instead of FileInfo[]
+ *
+ * Existing v1 backends can be adapted to this interface using
+ * {@link adaptBackendProtocol} from utils.
+ */
+interface BackendProtocolV2 extends Omit<BackendProtocolV1, "read" | "readRaw" | "grepRaw" | "lsInfo" | "globInfo"> {
+  /**
+   * Structured listing with file metadata.
+   *
+   * Lists files and directories in the specified directory (non-recursive).
+   * Directories have a trailing / in their path and is_dir=true.
+   *
+   * @param path - Absolute path to directory
+   * @returns LsResult with list of FileInfo objects on success or error on failure
+   */
+  ls(path: string): MaybePromise<LsResult>;
+  /**
+   * Read file content.
+   *
+   * For text files, content is paginated by line offset/limit.
+   * For binary files, the full raw Uint8Array content is returned.
+   *
+   * @param filePath - Absolute file path
+   * @param offset - Line offset to start reading from (0-indexed), default 0
+   * @param limit - Maximum number of lines to read, default 500
+   * @returns ReadResult with content on success or error on failure
+   */
+  read(filePath: string, offset?: number, limit?: number): MaybePromise<ReadResult>;
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns ReadRawResult with raw file data on success or error on failure
+   */
+  readRaw(filePath: string): MaybePromise<ReadRawResult>;
+  /**
+   * Search file contents for a literal text pattern.
+   *
+   * Binary files (determined by MIME type) are skipped.
+   *
+   * @param pattern - Literal text pattern to search for
+   * @param path - Base path to search from (default: null)
+   * @param glob - Optional glob pattern to filter files (e.g., "*.py")
+   * @returns GrepResult with matches on success or error on failure
+   */
+  grep(pattern: string, path?: string | null, glob?: string | null): MaybePromise<GrepResult>;
+  /**
+   * Structured glob matching returning FileInfo objects.
+   *
+   * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
+   * @param path - Base path to search from (default: "/")
+   * @returns GlobResult with list of FileInfo objects matching the pattern on success or error on failure
+   */
+  glob(pattern: string, path?: string): MaybePromise<GlobResult>;
+}
+/**
+ * Protocol for sandboxed backends with isolated runtime.
+ *
+ * Key differences from {@link SandboxBackendProtocol}:
+ * - Extends {@link BackendProtocolV2} instead of {@link BackendProtocol}
+ * - All methods return structured Result types for consistent error handling
+ */
+interface SandboxBackendProtocolV2 extends BackendProtocolV2 {
+  /**
+   * Execute a command in the sandbox.
+   *
+   * @param command - Full shell command string to execute
+   * @returns ExecuteResponse with combined output, exit code, and truncation flag
+   */
+  execute(command: string): MaybePromise<ExecuteResponse>;
+  /** Unique identifier for the sandbox backend instance */
+  readonly id: string;
+}
+//#endregion
 //#region src/backends/protocol.d.ts
+/** @deprecated Use {@link BackendProtocolV2} instead. */
+interface BackendProtocol extends BackendProtocolV1 {}
+/** @deprecated Use {@link SandboxBackendProtocolV2} instead. */
+interface SandboxBackendProtocol extends SandboxBackendProtocolV1 {}
 type MaybePromise<T> = T | Promise<T>;
 /**
  * Structured file listing info.
@@ -47,18 +249,97 @@ interface GrepMatch {
   text: string;
 }
 /**
- * File data structure used by backends.
+ * Structured result from grep/search operations.
+ */
+interface GrepResult {
+  /** Error message on failure, undefined on success */
+  error?: string;
+  /** Structured grep match entries, undefined on failure */
+  matches?: GrepMatch[];
+}
+/**
+ * Legacy file data format (v1).
  *
- * All file data is represented as objects with this structure:
+ * Content is stored as an array of lines (split on "\n"). This format
+ * only supports text files and is retained for backwards compatibility
+ * with existing state/store data.
  */
-interface FileData {
-  /** Lines of text content */
+interface FileDataV1 {
+  /** File content as an array of lines */
   content: string[];
   /** ISO format timestamp of creation */
   created_at: string;
   /** ISO format timestamp of last modification */
   modified_at: string;
 }
+/**
+ * Current file data format (v2).
+ *
+ * Content is stored as a string for text files, or as a Uint8Array for
+ * binary files (images, PDFs, audio, etc.). The MIME type is stored
+ * alongside the content, allowing backend implementations to determine
+ * it however they see fit (e.g. from file extension, HTTP headers,
+ * database metadata, etc.).
+ */
+interface FileDataV2 {
+  /** File content: string for text, Uint8Array for binary */
+  content: string | Uint8Array;
+  /** MIME type of the file (e.g. "image/png", "text/plain") */
+  mimeType: string;
+  /** ISO format timestamp of creation */
+  created_at: string;
+  /** ISO format timestamp of last modification */
+  modified_at: string;
+}
+/**
+ * Union of v1 and v2 file data formats.
+ *
+ * Backends may encounter either format when reading from state or store
+ * (v1 from legacy data, v2 from new writes). Use {@link isFileDataV1}
+ * from utils for runtime discrimination.
+ */
+type FileData = FileDataV1 | FileDataV2;
+/**
+ * Structured result from backend read operations.
+ *
+ * Replaces the previous plain string return, giving callers a
+ * programmatic way to distinguish errors from content.
+ */
+interface ReadResult {
+  /** Error message on failure, undefined on success */
+  error?: string;
+  /** File content: string for text, Uint8Array for binary. Undefined on failure. */
+  content?: string | Uint8Array;
+  /** MIME type of the file, when available */
+  mimeType?: string;
+}
+/**
+ * Structured result from backend readRaw operations.
+ */
+interface ReadRawResult {
+  /** Error message on failure, undefined on success */
+  error?: string;
+  /** Raw file data, undefined on failure */
+  data?: FileData;
+}
+/**
+ * Structured result from backend ls operations.
+ */
+interface LsResult {
+  /** Error message on failure, undefined on success */
+  error?: string;
+  /** List of FileInfo objects, undefined on failure */
+  files?: FileInfo[];
+}
+/**
+ * Structured result from backend glob operations.
+ */
+interface GlobResult {
+  /** Error message on failure, undefined on success */
+  error?: string;
+  /** List of FileInfo objects matching the pattern, undefined on failure */
+  files?: FileInfo[];
+}
 /**
  * Result from backend write operations.
  *
@@ -74,6 +355,9 @@ interface WriteResult {
    * State update dict for checkpoint backends, null for external storage.
    * Checkpoint backends populate this with {file_path: file_data} for LangGraph state.
    * External backends set null (already persisted to disk/S3/database/etc).
+   *
+   * @deprecated Zero-arg backends send state updates internally via
+   * `__pregel_send`. Check `if (result.filesUpdate)` before using.
    */
   filesUpdate?: Record<string, FileData> | null;
   /** Metadata for the write operation, attached to the ToolMessage */
@@ -94,6 +378,9 @@ interface EditResult {
    * State update dict for checkpoint backends, null for external storage.
    * Checkpoint backends populate this with {file_path: file_data} for LangGraph state.
    * External backends set null (already persisted to disk/S3/database/etc).
+   *
+   * @deprecated Zero-arg backends send state updates internally via
+   * `__pregel_send`. Check `if (result.filesUpdate)` before using.
    */
   filesUpdate?: Record<string, FileData> | null;
   /** Number of replacements made, undefined on failure */
@@ -138,120 +425,36 @@ interface FileUploadResponse {
   error: FileOperationError | null;
 }
 /**
- * Protocol for pluggable memory backends (single, unified).
+ * Common options shared across backend constructors.
+ */
+interface BackendOptions {
+  /** File data format to use for new writes. Defaults to "v2". */
+  fileFormat?: "v1" | "v2";
+}
+/**
+ * Type guard to check if a backend supports execution.
  *
- * Backends can store files in different locations (state, filesystem, database, etc.)
- * and provide a uniform interface for file operations.
+ * @param backend - Backend instance to check
+ * @returns True if the backend implements SandboxBackendProtocolV2
+ */
+declare function isSandboxBackend(backend: unknown): backend is SandboxBackendProtocolV2;
+/**
+ * Union of v1 and v2 sandbox backend protocols.
  *
- * All file data is represented as objects with the FileData structure.
+ * Use this when accepting either protocol version. Pass through
+ * {@link adaptSandboxProtocol} to normalize to {@link SandboxBackendProtocolV2}.
+ */
+type AnySandboxProtocol = SandboxBackendProtocol | SandboxBackendProtocolV2;
+/**
+ * Type guard to check if a backend is a sandbox protocol (v1 or v2).
  *
- * Methods can return either direct values or Promises, allowing both
- * synchronous and asynchronous implementations.
+ * Checks for the presence of `execute` function and `id` string,
+ * which are the defining features of sandbox protocols.
+ *
+ * @param backend - Backend instance to check
+ * @returns True if the backend implements sandbox protocol (v1 or v2)
  */
-interface BackendProtocol {
-  /**
-   * Structured listing with file metadata.
-   *
-   * Lists files and directories in the specified directory (non-recursive).
-   * Directories have a trailing / in their path and is_dir=true.
-   *
-   * @param path - Absolute path to directory
-   * @returns List of FileInfo objects for files and directories directly in the directory
-   */
-  lsInfo(path: string): MaybePromise<FileInfo[]>;
-  /**
-   * Read file content with line numbers or an error string.
-   *
-   * @param filePath - Absolute file path
-   * @param offset - Line offset to start reading from (0-indexed), default 0
-   * @param limit - Maximum number of lines to read, default 500
-   * @returns Formatted file content with line numbers, or error message
-   */
-  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.
-   *
-   * Searches file contents for a regex pattern.
-   *
-   * @param pattern - Regex pattern to search for
-   * @param path - Base path to search from (default: null)
-   * @param glob - Optional glob pattern to filter files (e.g., "*.py")
-   * @returns List of GrepMatch objects or error string for invalid regex
-   */
-  grepRaw(pattern: string, path?: string | null, glob?: string | null): MaybePromise<GrepMatch[] | string>;
-  /**
-   * Structured glob matching returning FileInfo objects.
-   *
-   * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
-   * @param path - Base path to search from (default: "/")
-   * @returns List of FileInfo objects matching the pattern
-   */
-  globInfo(pattern: string, path?: string): MaybePromise<FileInfo[]>;
-  /**
-   * Create a new file.
-   *
-   * @param filePath - Absolute file path
-   * @param content - File content as string
-   * @returns WriteResult with error populated on failure
-   */
-  write(filePath: string, content: string): MaybePromise<WriteResult>;
-  /**
-   * Edit a file by replacing string occurrences.
-   *
-   * @param filePath - Absolute file path
-   * @param oldString - String to find and replace
-   * @param newString - Replacement string
-   * @param replaceAll - If true, replace all occurrences (default: false)
-   * @returns EditResult with error, path, filesUpdate, and occurrences
-   */
-  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): MaybePromise<EditResult>;
-  /**
-   * 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?(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[]>;
-}
-/**
- * Protocol for sandboxed backends with isolated runtime.
- * Sandboxed backends run in isolated environments (e.g., containers)
- * and communicate via defined interfaces.
- */
-interface SandboxBackendProtocol extends BackendProtocol {
-  /**
-   * Execute a command in the sandbox.
-   *
-   * @param command - Full shell command string to execute
-   * @returns ExecuteResponse with combined output, exit code, and truncation flag
-   */
-  execute(command: string): MaybePromise<ExecuteResponse>;
-  /** Unique identifier for the sandbox backend instance */
-  readonly id: string;
-}
-/**
- * Type guard to check if a backend supports execution.
- *
- * @param backend - Backend instance to check
- * @returns True if the backend implements SandboxBackendProtocol
- */
-declare function isSandboxBackend(backend: BackendProtocol): backend is SandboxBackendProtocol;
+declare function isSandboxProtocol(backend: unknown): backend is AnySandboxProtocol;
 /**
  * Metadata for a single sandbox instance.
  *
@@ -423,8 +626,18 @@ interface StateAndStore {
   /** Optional assistant ID for per-assistant isolation in store */
   assistantId?: string;
 }
+/**
+ * Union of v1 and v2 backend protocols.
+ *
+ * Use this when accepting either protocol version. Pass through
+ * {@link adaptBackendProtocol} to normalize to {@link BackendProtocolV2}.
+ */
+type AnyBackendProtocol = BackendProtocolV1 | BackendProtocolV2;
 /**
  * Agent {@link Runtime} with `state`
+ *
+ * @deprecated Backends now read state from the LangGraph execution context
+ * via `getCurrentTaskInput()`, `getConfig()`, and `getStore()`.
  */
 interface BackendRuntime<StateT = unknown> extends Runtime {
   /** Current agent state with files, messages, etc. */
@@ -436,6 +649,9 @@ interface BackendRuntime<StateT = unknown> extends Runtime {
  * Backends receive {@link BackendRuntime} which contains the current state
  * and runtime information, extracted from the execution context.
  *
+ * @deprecated Pass a pre-constructed backend instance instead of a factory.
+ * E.g., `backend: new StateBackend()` instead of `backend: (runtime) => new StateBackend(runtime)`.
+ *
  * @example
  * ```typescript
  * // Using in middleware
@@ -444,15 +660,17 @@ interface BackendRuntime<StateT = unknown> extends Runtime {
  * });
  * ```
  */
-type BackendFactory = (runtime: BackendRuntime) => MaybePromise<BackendProtocol>;
+type BackendFactory = (runtime: BackendRuntime) => MaybePromise<AnyBackendProtocol>;
 /**
  * Resolve a backend instance or await a {@link BackendFactory}.
  *
  * Accepts {@link BackendRuntime} or {@link ToolRuntime} — store typing differs
  * between LangGraph checkpoint stores and core `ToolRuntime`; factories receive
  * a value that is structurally compatible at runtime.
+ *
+ * @internal
  */
-declare function resolveBackend(backend: BackendProtocol | BackendFactory, runtime: BackendRuntime | ToolRuntime): Promise<BackendProtocol>;
+declare function resolveBackend(backend: AnyBackendProtocol | BackendFactory, runtime: BackendRuntime | ToolRuntime): Promise<BackendProtocolV2>;
 //#endregion
 //#region src/middleware/fs.d.ts
 /**
@@ -468,7 +686,7 @@ type FilesRecordUpdate = Record<string, FileData | null>;
  */
 interface FilesystemMiddlewareOptions {
   /** Backend instance or factory (default: StateBackend) */
-  backend?: BackendProtocol | BackendFactory;
+  backend?: AnyBackendProtocol | BackendFactory;
   /** Optional custom system prompt override */
   systemPrompt?: string | null;
   /** Optional custom tool descriptions override */
@@ -501,7 +719,14 @@ declare function createFilesystemMiddleware(options?: FilesystemMiddlewareOption
   file_path: string;
   offset?: unknown;
   limit?: unknown;
-}, string, unknown, "read_file"> | _langchain.DynamicStructuredTool<z.ZodObject<{
+}, {
+  type: string;
+  text: string;
+}[] | {
+  type: string;
+  mimeType: string;
+  data: string;
+}[], unknown, "read_file"> | _langchain.DynamicStructuredTool<z.ZodObject<{
   file_path: z.ZodString;
   content: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>, {
@@ -543,11 +768,11 @@ declare function createFilesystemMiddleware(options?: FilesystemMiddlewareOption
 }, string, unknown, "glob"> | _langchain.DynamicStructuredTool<z.ZodObject<{
   pattern: z.ZodString;
   path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-  glob: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+  glob: z.ZodDefault<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
 }, z.core.$strip>, {
   pattern: string;
   path: string;
-  glob?: string | null | undefined;
+  glob: string | null;
 }, {
   pattern: string;
   path?: string | undefined;
@@ -560,1354 +785,1649 @@ declare function createFilesystemMiddleware(options?: FilesystemMiddlewareOption
   command: string;
 }, string, unknown, "execute">)[]>;
 //#endregion
-//#region src/middleware/subagents.d.ts
-/**
- * Default system prompt for subagents.
- * Provides a minimal base prompt that can be extended by specific subagent configurations.
- */
-declare const DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
-/**
- * Default description for the general-purpose subagent.
- * This description is shown to the model when selecting which subagent to use.
- */
-declare 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.";
-/**
- * System prompt section that explains how to use the task tool for spawning subagents.
- *
- * This prompt is automatically appended to the main agent's system prompt when
- * using `createSubAgentMiddleware`. It provides guidance on:
- * - When to use the task tool
- * - Subagent lifecycle (spawn → run → return → reconcile)
- * - When NOT to use the task tool
- * - Best practices for parallel task execution
- *
- * You can provide a custom `systemPrompt` to `createSubAgentMiddleware` to override
- * or extend this default.
- */
-declare const TASK_SYSTEM_PROMPT = "## `task` (subagent spawner)\n\nYou have access to a `task` tool to launch short-lived subagents that handle isolated tasks. These agents are ephemeral \u2014 they live only for the duration of the task and return a single result.\n\nWhen to use the task tool:\n- When a task is complex and multi-step, and can be fully delegated in isolation\n- When a task is independent of other tasks and can run in parallel\n- When a task requires focused reasoning or heavy token/context usage that would bloat the orchestrator thread\n- When sandboxing improves reliability (e.g. code execution, structured searches, data formatting)\n- When you only care about the output of the subagent, and not the intermediate steps (ex. performing a lot of research and then returned a synthesized report, performing a series of computations or lookups to achieve a concise, relevant answer.)\n\nSubagent lifecycle:\n1. **Spawn** \u2192 Provide clear role, instructions, and expected output\n2. **Run** \u2192 The subagent completes the task autonomously\n3. **Return** \u2192 The subagent provides a single structured result\n4. **Reconcile** \u2192 Incorporate or synthesize the result into the main thread\n\nWhen NOT to use the task tool:\n- If you need to see the intermediate reasoning or steps after the subagent has completed (the task tool hides them)\n- If the task is trivial (a few tool calls or simple lookup)\n- If delegating does not reduce token usage, complexity, or context switching\n- If splitting would add latency without benefit\n\n## Important Task Tool Usage Notes to Remember\n- Whenever possible, parallelize the work that you do. This is true for both tool_calls, and for tasks. Whenever you have independent steps to complete - make tool_calls, or kick off tasks (subagents) in parallel to accomplish them faster. This saves time for the user, which is incredibly important.\n- Remember to use the `task` tool to silo independent tasks within a multi-part objective.\n- You should use the `task` tool whenever you have a complex task that will take multiple steps, and is independent from other tasks that the agent needs to complete. These agents are highly competent and efficient.";
-/**
- * Type definitions for pre-compiled agents.
- *
- * @typeParam TRunnable - The type of the runnable (ReactAgent or Runnable).
- *   When using `createAgent` or `createDeepAgent`, this preserves the middleware
- *   types for type inference. Uses `ReactAgent<any>` to accept agents with any
- *   type configuration (including DeepAgent instances).
- */
-interface CompiledSubAgent<TRunnable extends ReactAgent<any> | Runnable = ReactAgent<any> | Runnable> {
-  /** The name of the agent */
-  name: string;
-  /** The description of the agent */
-  description: string;
-  /** The agent instance */
-  runnable: TRunnable;
-}
+//#region src/backends/state.d.ts
 /**
- * Specification for a subagent that can be dynamically created.
- *
- * When using `createDeepAgent`, subagents automatically receive a default middleware
- * stack (todoListMiddleware, filesystemMiddleware, summarizationMiddleware, etc.) before
- * any custom `middleware` specified in this spec.
- *
- * Required fields:
- * - `name`: Identifier used to select this subagent in the task tool
- * - `description`: Shown to the model for subagent selection
- * - `systemPrompt`: The system prompt for the subagent
+ * Backend that stores files in agent state (ephemeral).
  *
- * Optional fields:
- * - `model`: Override the default model for this subagent
- * - `tools`: Override the default tools for this subagent
- * - `middleware`: Additional middleware appended after defaults
- * - `interruptOn`: Human-in-the-loop configuration for specific tools
- * - `skills`: Skill source paths for SkillsMiddleware (e.g., `["/skills/user/", "/skills/project/"]`)
+ * Uses LangGraph's state management and checkpointing. Files persist within
+ * a conversation thread but not across threads. State is automatically
+ * checkpointed after each agent step.
  *
- * @example
- * ```typescript
- * const researcher: SubAgent = {
- *   name: "researcher",
- *   description: "Research assistant for complex topics",
- *   systemPrompt: "You are a research assistant.",
- *   tools: [webSearchTool],
- *   skills: ["/skills/research/"],
- * };
- * ```
+ * Special handling: Since LangGraph state must be updated via Command objects
+ * (not direct mutation), operations return filesUpdate in WriteResult/EditResult
+ * for the middleware to apply via Command.
  */
-interface SubAgent {
-  /** Identifier used to select this subagent in the task tool */
-  name: string;
-  /** Description shown to the model for subagent selection */
-  description: string;
-  /** The system prompt to use for the agent */
-  systemPrompt: string;
-  /** The tools to use for the agent (tool instances, not names). Defaults to defaultTools */
-  tools?: StructuredTool[];
-  /** The model for the agent. Defaults to defaultModel */
-  model?: LanguageModelLike | string;
-  /** Additional middleware to append after default_middleware */
-  middleware?: readonly AgentMiddleware$1[];
-  /** Human-in-the-loop configuration for specific tools. Requires a checkpointer. */
-  interruptOn?: Record<string, boolean | InterruptOnConfig>;
+declare class StateBackend implements BackendProtocolV2 {
+  private runtime;
+  private fileFormat;
+  constructor(options?: BackendOptions);
   /**
-   * Skill source paths for SkillsMiddleware.
+   * @deprecated Pass no `runtime` argument
+   */
+  constructor(runtime: BackendRuntime, options?: BackendOptions);
+  /**
+   * Whether this instance was constructed with the legacy factory pattern.
    *
-   * List of paths to skill directories (e.g., `["/skills/user/", "/skills/project/"]`).
-   * When specified, the subagent will have its own SkillsMiddleware that loads skills
-   * from these paths. This allows subagents to have different skill sets than the main agent.
+   * When true, state is read from the injected `runtime` and `filesUpdate`
+   * is returned to the caller. When false, state is read from LangGraph's
+   * execution context and updates are sent via `__pregel_send`.
+   */
+  private get isLegacy();
+  /**
+   * Get files from current state.
    *
-   * Note: Custom subagents do NOT inherit skills from the main agent by default.
-   * Only the general-purpose subagent inherits the main agent's skills.
+   * In legacy mode, reads from the injected {@link BackendRuntime}.
+   * In zero-arg mode, reads from the LangGraph execution context via
+   * {@link getCurrentTaskInput}.
+   */
+  private getFiles;
+  /**
+   * Push a files state update through LangGraph's internal send channel.
    *
-   * @example
-   * ```typescript
-   * const researcher: SubAgent = {
-   *   name: "researcher",
-   *   description: "Research assistant",
-   *   systemPrompt: "You are a researcher.",
-   *   skills: ["/skills/research/", "/skills/web-search/"],
-   * };
-   * ```
+   * In zero-arg mode, sends the update via the `__pregel_send` function
+   * from {@link getConfig}, mirroring Python's `CONFIG_KEY_SEND`.
+   * In legacy mode, this is a no-op — the caller uses `filesUpdate`
+   * from the return value instead.
+   *
+   * @param update - Map of file paths to their updated {@link FileData}
    */
-  skills?: string[];
+  private sendFilesUpdate;
   /**
-   * Structured output response format for the subagent.
+   * List files and directories in the specified directory (non-recursive).
    *
-   * When specified, the subagent will produce a `structuredResponse` conforming to the
-   * given schema. The structured response is JSON-serialized and returned as the
-   * ToolMessage content to the parent agent, replacing the default last-message extraction.
+   * @param path - Absolute path to directory
+   * @returns LsResult with list of FileInfo objects on success or error on failure.
+   *          Directories have a trailing / in their path and is_dir=true.
+   */
+  ls(path: string): LsResult;
+  /**
+   * Read file content.
    *
-   * Accepts any format supported by `createAgent`: Zod schemas, JSON schema objects,
-   * `toolStrategy(schema)`, `providerStrategy(schema)`, etc.
+   * Text files are paginated by line offset/limit.
+   * Binary files return full Uint8Array content (offset/limit ignored).
    *
-   * @example
-   * ```typescript
-   * import { z } from "zod"
+   * @param filePath - Absolute file path
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns ReadResult with content on success or error on failure
+   */
+  read(filePath: string, offset?: number, limit?: number): ReadResult;
+  /**
+   * Read file content as raw FileData.
    *
-   * const analyzer: SubAgent = {
-   *   name: "analyzer",
-   *   description: "Analyzes data and returns structured findings",
-   *   systemPrompt: "Analyze the data and return your findings.",
-   *   responseFormat: z.object({
-   *     findings: z.string(),
-   *     confidence: z.number(),
-   *   }),
-   * };
-   * ```
+   * @param filePath - Absolute file path
+   * @returns ReadRawResult with raw file data on success or error on failure
    */
-  responseFormat?: CreateAgentParams["responseFormat"];
+  readRaw(filePath: string): ReadRawResult;
+  /**
+   * Create a new file with content.
+   * Returns WriteResult with filesUpdate to update LangGraph state.
+   */
+  write(filePath: string, content: string): WriteResult;
+  /**
+   * Edit a file by replacing string occurrences.
+   * Returns EditResult with filesUpdate and occurrences.
+   */
+  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): EditResult;
+  /**
+   * Search file contents for a literal text pattern.
+   * Binary files are skipped.
+   */
+  grep(pattern: string, path?: string, glob?: string | null): GrepResult;
+  /**
+   * Structured glob matching returning FileInfo objects.
+   */
+  glob(pattern: string, path?: string): GlobResult;
+  /**
+   * Upload multiple files.
+   *
+   * Note: Since LangGraph state must be updated via Command objects,
+   * the caller must apply filesUpdate via Command after calling this method.
+   *
+   * @param files - List of [path, content] tuples to upload
+   * @returns List of FileUploadResponse objects, one per input file
+   */
+  uploadFiles(files: Array<[string, Uint8Array]>): FileUploadResponse[] & {
+    filesUpdate?: Record<string, FileData>;
+  };
+  /**
+   * Download multiple files.
+   *
+   * @param paths - List of file paths to download
+   * @returns List of FileDownloadResponse objects, one per input path
+   */
+  downloadFiles(paths: string[]): FileDownloadResponse[];
 }
+//#endregion
+//#region src/backends/store.d.ts
 /**
- * Base specification for the general-purpose subagent.
- *
- * This constant provides the default configuration for the general-purpose subagent
- * that is automatically included when `generalPurposeAgent: true` (the default).
- *
- * The general-purpose subagent:
- * - Has access to all tools from the main agent
- * - Inherits skills from the main agent (when skills are configured)
- * - Uses the same model as the main agent (by default)
- * - Is ideal for delegating complex, multi-step tasks
- *
- * You can spread this constant and override specific properties when creating
- * custom subagents that should behave similarly to the general-purpose agent:
- *
- * @example
- * ```typescript
- * import { GENERAL_PURPOSE_SUBAGENT, createDeepAgent } from "@anthropic/deepagents";
- *
- * // Use as-is (automatically included with generalPurposeAgent: true)
- * const agent = createDeepAgent({ model: "claude-sonnet-4-5-20250929" });
- *
- * // Or create a custom variant with different tools
- * const customGP: SubAgent = {
- *   ...GENERAL_PURPOSE_SUBAGENT,
- *   name: "research-gp",
- *   tools: [webSearchTool, readFileTool],
- * };
- *
- * const agent = createDeepAgent({
- *   model: "claude-sonnet-4-5-20250929",
- *   subagents: [customGP],
- *   // Disable the default general-purpose agent since we're providing our own
- *   // (handled automatically when using createSubAgentMiddleware directly)
- * });
- * ```
- */
-declare const GENERAL_PURPOSE_SUBAGENT: Pick<SubAgent, "name" | "description" | "systemPrompt">;
-/**
- * Options for creating subagent middleware
+ * Options for StoreBackend constructor.
  */
-interface SubAgentMiddlewareOptions {
-  /** The model to use for subagents */
-  defaultModel: LanguageModelLike | string;
-  /** The tools to use for the default general-purpose subagent */
-  defaultTools?: StructuredTool[];
-  /** Default middleware to apply to custom subagents (WITHOUT skills from main agent) */
-  defaultMiddleware?: AgentMiddleware$1[] | null;
+interface StoreBackendOptions extends BackendOptions {
   /**
-   * Middleware specifically for the general-purpose subagent (includes skills from main agent).
-   * If not provided, falls back to defaultMiddleware.
+   * Custom namespace for store operations.
+   *
+   * Determines where files are stored in the LangGraph store, enabling
+   * user-scoped, org-scoped, or any custom isolation pattern.
+   *
+   * If not provided, falls back to legacy behavior using assistantId from {@link BackendRuntime}.
+   *
+   * @example
+   * ```typescript
+   * // User-scoped storage
+   * new StoreBackend(runtime, {
+   *   namespace: ["memories", orgId, userId, "filesystem"],
+   * });
+   *
+   * // Org-scoped storage
+   * new StoreBackend(runtime, {
+   *   namespace: ["memories", orgId, "filesystem"],
+   * });
+   * ```
    */
-  generalPurposeMiddleware?: AgentMiddleware$1[] | null;
-  /** The tool configs for the default general-purpose subagent */
-  defaultInterruptOn?: Record<string, boolean | InterruptOnConfig> | null;
-  /** A list of additional subagents to provide to the agent */
-  subagents?: (SubAgent | CompiledSubAgent)[];
-  /** Full system prompt override */
-  systemPrompt?: string | null;
-  /** Whether to include the general-purpose agent */
-  generalPurposeAgent?: boolean;
-  /** Custom description for the task tool */
-  taskDescription?: string | null;
+  namespace?: string[];
 }
 /**
- * Create subagent middleware with task tool
- */
-declare function createSubAgentMiddleware(options: SubAgentMiddlewareOptions): AgentMiddleware$1<undefined, undefined, unknown, readonly [_langchain.DynamicStructuredTool<z.ZodObject<{
-  description: z.ZodString;
-  subagent_type: z.ZodString;
-}, z.core.$strip>, {
-  description: string;
-  subagent_type: string;
-}, {
-  description: string;
-  subagent_type: string;
-}, string | Command<unknown, Record<string, unknown>, string>, unknown, "task">]>;
-//#endregion
-//#region src/middleware/patch_tool_calls.d.ts
-/**
- * Create middleware that enforces strict tool call / tool response parity in
- * the messages history.
- *
- * Two kinds of violations are repaired:
- * 1. **Dangling tool_calls** — an AIMessage contains tool_calls with no
- *    matching ToolMessage responses. Synthetic cancellation ToolMessages are
- *    injected so every tool_call has a response.
- * 2. **Orphaned ToolMessages** — a ToolMessage exists whose `tool_call_id`
- *    does not match any tool_call in a preceding AIMessage. These are removed.
- *
- * This is critical for providers like Google Gemini that reject requests with
- * mismatched function call / function response counts (400 INVALID_ARGUMENT).
- *
- * This middleware patches in two places:
- * 1. `beforeAgent`: Patches state at the start of the agent loop (handles most cases)
- * 2. `wrapModelCall`: Patches the request right before model invocation (handles
- *    edge cases like HITL rejection during graph resume where state updates from
- *    beforeAgent may not be applied in time)
- *
- * @returns AgentMiddleware that enforces tool call / response parity
- *
- * @example
- * ```typescript
- * import { createAgent } from "langchain";
- * import { createPatchToolCallsMiddleware } from "./middleware/patch_tool_calls";
- *
- * const agent = createAgent({
- *   model: "claude-sonnet-4-5-20250929",
- *   middleware: [createPatchToolCallsMiddleware()],
- * });
- * ```
- */
-declare function createPatchToolCallsMiddleware(): AgentMiddleware<undefined, undefined, unknown, readonly (_langchain_core_tools0.ClientTool | _langchain_core_tools0.ServerTool)[]>;
-//#endregion
-//#region src/backends/state.d.ts
-/**
- * Backend that stores files in agent state (ephemeral).
+ * Backend that stores files in LangGraph's BaseStore (persistent).
  *
- * Uses LangGraph's state management and checkpointing. Files persist within
- * a conversation thread but not across threads. State is automatically
- * checkpointed after each agent step.
+ * Uses LangGraph's Store for persistent, cross-conversation storage.
+ * Files are organized via namespaces and persist across all threads.
  *
- * Special handling: Since LangGraph state must be updated via Command objects
- * (not direct mutation), operations return filesUpdate in WriteResult/EditResult
- * for the middleware to apply via Command.
+ * The namespace can be customized via a factory function for flexible
+ * isolation patterns (user-scoped, org-scoped, etc.), or falls back
+ * to legacy assistant_id-based isolation.
  */
-declare class StateBackend implements BackendProtocol {
-  private runtime;
-  constructor(runtime: BackendRuntime);
+declare class StoreBackend implements BackendProtocolV2 {
+  private stateAndStore;
+  private _namespace;
+  private fileFormat;
+  constructor(options?: StoreBackendOptions);
   /**
-   * Get files from current state.
+   * @deprecated Pass no `stateAndStore` argument
    */
-  private getFiles;
+  constructor(stateAndStore: StateAndStore, options?: StoreBackendOptions);
+  /**
+   * Get the BaseStore instance for persistent storage operations.
+   *
+   * In legacy mode, reads from the injected {@link StateAndStore}.
+   * In zero-arg mode, retrieves the store from the LangGraph execution
+   * context via {@link getLangGraphStore}.
+   *
+   * @returns BaseStore instance
+   * @throws Error if no store is available in either mode
+   */
+  private getStore;
+  /**
+   * Get the namespace for store operations.
+   *
+   * Resolution order:
+   * 1. Explicit namespace from constructor options (both modes)
+   * 2. Legacy mode: `[assistantId, "filesystem"]` fallback from {@link StateAndStore}
+   * 3. Zero-arg mode without namespace: `["filesystem"]` with a deprecation warning
+   *    nudging callers to pass an explicit namespace
+   * 4. Legacy mode without assistantId: `["filesystem"]`
+   */
+  protected getNamespace(): string[];
+  /**
+   * Convert a store Item to FileData format.
+   *
+   * @param storeItem - The store Item containing file data
+   * @returns FileData object
+   * @throws Error if required fields are missing or have incorrect types
+   */
+  private convertStoreItemToFileData;
+  /**
+   * Convert FileData to a value suitable for store.put().
+   *
+   * @param fileData - The FileData to convert
+   * @returns Object with content, mimeType, created_at, and modified_at fields
+   */
+  private convertFileDataToStoreValue;
+  /**
+   * Search store with automatic pagination to retrieve all results.
+   *
+   * @param store - The store to search
+   * @param namespace - Hierarchical path prefix to search within
+   * @param options - Optional query, filter, and page_size
+   * @returns List of all items matching the search criteria
+   */
+  private searchStorePaginated;
   /**
    * List files and directories in the specified directory (non-recursive).
    *
    * @param path - Absolute path to directory
-   * @returns List of FileInfo objects for files and directories directly in the directory.
+   * @returns LsResult with list of FileInfo objects on success or error on failure.
    *          Directories have a trailing / in their path and is_dir=true.
    */
-  lsInfo(path: string): FileInfo[];
+  ls(path: string): Promise<LsResult>;
   /**
-   * Read file content with line numbers.
+   * Read file content.
+   *
+   * Text files are paginated by line offset/limit.
+   * Binary files return full Uint8Array content (offset/limit ignored).
    *
    * @param filePath - Absolute file path
    * @param offset - Line offset to start reading from (0-indexed)
    * @param limit - Maximum number of lines to read
-   * @returns Formatted file content with line numbers, or error message
+   * @returns ReadResult with content on success or error on failure
    */
-  read(filePath: string, offset?: number, limit?: number): string;
+  read(filePath: string, offset?: number, limit?: number): Promise<ReadResult>;
   /**
    * Read file content as raw FileData.
    *
    * @param filePath - Absolute file path
-   * @returns Raw file content as FileData
+   * @returns ReadRawResult with raw file data on success or error on failure
    */
-  readRaw(filePath: string): FileData;
+  readRaw(filePath: string): Promise<ReadRawResult>;
   /**
    * Create a new file with content.
-   * Returns WriteResult with filesUpdate to update LangGraph state.
+   * Returns WriteResult. External storage sets filesUpdate=null.
    */
-  write(filePath: string, content: string): WriteResult;
+  write(filePath: string, content: string): Promise<WriteResult>;
   /**
    * Edit a file by replacing string occurrences.
-   * Returns EditResult with filesUpdate and occurrences.
+   * Returns EditResult. External storage sets filesUpdate=null.
    */
-  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): EditResult;
+  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
   /**
-   * Structured search results or error string for invalid input.
+   * Search file contents for a literal text pattern.
+   * Binary files are skipped.
    */
-  grepRaw(pattern: string, path?: string, glob?: string | null): GrepMatch[] | string;
+  grep(pattern: string, path?: string, glob?: string | null): Promise<GrepResult>;
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  globInfo(pattern: string, path?: string): FileInfo[];
+  glob(pattern: string, path?: string): Promise<GlobResult>;
   /**
    * Upload multiple files.
    *
-   * Note: Since LangGraph state must be updated via Command objects,
-   * the caller must apply filesUpdate via Command after calling this method.
-   *
    * @param files - List of [path, content] tuples to upload
    * @returns List of FileUploadResponse objects, one per input file
    */
-  uploadFiles(files: Array<[string, Uint8Array]>): FileUploadResponse[] & {
-    filesUpdate?: Record<string, FileData>;
-  };
+  uploadFiles(files: Array<[string, Uint8Array]>): Promise<FileUploadResponse[]>;
   /**
    * Download multiple files.
    *
    * @param paths - List of file paths to download
    * @returns List of FileDownloadResponse objects, one per input path
    */
-  downloadFiles(paths: string[]): FileDownloadResponse[];
+  downloadFiles(paths: string[]): Promise<FileDownloadResponse[]>;
 }
 //#endregion
-//#region src/middleware/memory.d.ts
+//#region src/backends/filesystem.d.ts
 /**
- * Options for the memory middleware.
+ * Backend that reads and writes files directly from the filesystem.
+ *
+ * Files are accessed using their actual filesystem paths. Relative paths are
+ * resolved relative to the current working directory. Content is read/written
+ * as plain text, and metadata (timestamps) are derived from filesystem stats.
  */
-interface MemoryMiddlewareOptions {
+declare class FilesystemBackend implements BackendProtocolV2 {
+  protected cwd: string;
+  protected virtualMode: boolean;
+  private maxFileSizeBytes;
+  constructor(options?: {
+    rootDir?: string;
+    virtualMode?: boolean;
+    maxFileSizeMb?: number;
+  });
   /**
-   * Backend instance or factory function for file operations.
-   * Use a factory for StateBackend since it requires runtime state.
+   * Resolve a file path with security checks.
+   *
+   * When virtualMode=true, treat incoming paths as virtual absolute paths under
+   * this.cwd, disallow traversal (.., ~) and ensure resolved path stays within root.
+   * When virtualMode=false, preserve legacy behavior: absolute paths are allowed
+   * as-is; relative paths resolve under cwd.
+   *
+   * @param key - File path (absolute, relative, or virtual when virtualMode=true)
+   * @returns Resolved absolute path string
+   * @throws Error if path traversal detected or path outside root
    */
-  backend: BackendProtocol | BackendFactory | ((config: {
-    state: unknown;
-    store?: BaseStore;
-  }) => StateBackend);
+  private resolvePath;
   /**
-   * List of memory file paths to load (e.g., ["~/.deepagents/AGENTS.md", "./.deepagents/AGENTS.md"]).
-   * Display names are automatically derived from the paths.
-   * Sources are loaded in order.
+   * List files and directories in the specified directory (non-recursive).
+   *
+   * @param dirPath - Absolute directory path to list files from
+   * @returns List of FileInfo objects for files and directories directly in the directory.
+   *          Directories have a trailing / in their path and is_dir=true.
    */
-  sources: string[];
+  ls(dirPath: string): Promise<LsResult>;
   /**
-   * Whether to add cache_control breakpoints to the memory content block.
-   * When true, the memory block is tagged with `cache_control: { type: "ephemeral" }`
-   * to enable prompt caching for providers that support it (e.g., Anthropic).
-   * @default false
+   * Read file content with line numbers.
+   *
+   * @param filePath - Absolute or relative file path
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns Formatted file content with line numbers, or error message
    */
-  addCacheControl?: boolean;
-}
-/**
- * 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",
- *   ],
- * });
- * ```
- */
-declare function createMemoryMiddleware(options: MemoryMiddlewareOptions): AgentMiddleware<StateSchema<{
+  read(filePath: string, offset?: number, limit?: number): Promise<ReadResult>;
   /**
-   * Dict mapping source paths to their loaded content.
-   * Marked as private so it's not included in the final agent state.
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns ReadRawResult with raw file data on success or error on failure
    */
-  memoryContents: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
-  files: _langgraph.ReducedValue<FilesRecord | undefined, FilesRecordUpdate | undefined>;
-}>, undefined, unknown, readonly (_langchain_core_tools0.ClientTool | _langchain_core_tools0.ServerTool)[]>;
-//#endregion
-//#region src/middleware/skills.d.ts
-declare const MAX_SKILL_FILE_SIZE: number;
-declare const MAX_SKILL_NAME_LENGTH = 64;
-declare const MAX_SKILL_DESCRIPTION_LENGTH = 1024;
-/**
- * Metadata for a skill per Agent Skills specification.
- */
-interface SkillMetadata$1 {
+  readRaw(filePath: string): Promise<ReadRawResult>;
   /**
-   * Skill identifier.
-   *
-   * Constraints per Agent Skills specification:
-   *
-   * - 1-64 characters
-   * - Unicode lowercase alphanumeric and hyphens only (`a-z` and `-`).
-   * - Must not start or end with `-`
-   * - Must not contain consecutive `--`
-   * - Must match the parent directory name containing the `SKILL.md` file
+   * Create a new file with content.
+   * Returns WriteResult. External storage sets filesUpdate=null.
    */
-  name: string;
+  write(filePath: string, content: string): Promise<WriteResult>;
   /**
-   * What the skill does.
-   *
-   * Constraints per Agent Skills specification:
-   *
-   * - 1-1024 characters
-   * - Should describe both what the skill does and when to use it
-   * - Should include specific keywords that help agents identify relevant tasks
+   * Edit a file by replacing string occurrences.
+   * Returns EditResult. External storage sets filesUpdate=null.
    */
-  description: string;
-  /** Path to the SKILL.md file in the backend */
-  path: string;
-  /** License name or reference to bundled license file. */
-  license?: string | null;
+  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
   /**
-   * Environment requirements.
+   * Search for a literal text pattern in files.
    *
-   * Constraints per Agent Skills specification:
+   * Uses ripgrep if available, falling back to substring search.
    *
-   * - 1-500 characters if provided
-   * - Should only be included if there are specific compatibility requirements
-   * - Can indicate intended product, required packages, etc.
+   * @param pattern - Literal string to search for (NOT regex).
+   * @param dirPath - Directory or file path to search in. Defaults to current directory.
+   * @param glob - Optional glob pattern to filter which files to search.
+   * @returns List of GrepMatch dicts containing path, line number, and matched text.
    */
-  compatibility?: string | null;
+  grep(pattern: string, dirPath?: string, glob?: string | null): Promise<GrepResult>;
   /**
-   * Arbitrary key-value mapping for additional metadata.
-   *
-   * Clients can use this to store additional properties not defined by the spec.
+   * Search using ripgrep with fixed-string (literal) mode.
    *
-   * It is recommended to keep key names unique to avoid conflicts.
+   * @param pattern - Literal string to search for (unescaped).
+   * @param baseFull - Resolved base path to search in.
+   * @param includeGlob - Optional glob pattern to filter files.
+   * @returns Dict mapping file paths to list of (line_number, line_text) tuples.
+   *          Returns null if ripgrep is unavailable or times out.
    */
-  metadata?: Record<string, string>;
+  private ripgrepSearch;
   /**
-   * Tool names the skill recommends using.
-   *
-   * Warning: this is experimental.
+   * Fallback search using literal substring matching when ripgrep is unavailable.
    *
-   * Constraints per Agent Skills specification:
+   * Recursively searches files, respecting maxFileSizeBytes limit.
    *
-   * - Space-delimited list of tool names
+   * @param pattern - Literal string to search for.
+   * @param baseFull - Resolved base path to search in.
+   * @param includeGlob - Optional glob pattern to filter files by name.
+   * @returns Dict mapping file paths to list of (line_number, line_text) tuples.
    */
-  allowedTools?: string[];
-}
-/**
- * Options for the skills middleware.
- */
-interface SkillsMiddlewareOptions {
+  private literalSearch;
   /**
-   * Backend instance or factory function for file operations.
-   * Use a factory for StateBackend since it requires runtime state.
+   * Structured glob matching returning FileInfo objects.
    */
-  backend: BackendProtocol | BackendFactory | ((config: {
-    state: unknown;
-    store?: BaseStore;
-  }) => StateBackend);
+  glob(pattern: string, searchPath?: string): Promise<GlobResult>;
   /**
-   * List of skill source paths to load (e.g., ["/skills/user/", "/skills/project/"]).
-   * Paths must use POSIX conventions (forward slashes).
-   * Later sources override earlier ones for skills with the same name (last one wins).
+   * Upload multiple files to the filesystem.
+   *
+   * @param files - List of [path, content] tuples to upload
+   * @returns List of FileUploadResponse objects, one per input file
    */
-  sources: string[];
+  uploadFiles(files: Array<[string, Uint8Array]>): Promise<FileUploadResponse[]>;
+  /**
+   * Download multiple files from the filesystem.
+   *
+   * @param paths - List of file paths to download
+   * @returns List of FileDownloadResponse objects, one per input path
+   */
+  downloadFiles(paths: string[]): Promise<FileDownloadResponse[]>;
 }
+//#endregion
+//#region src/backends/composite.d.ts
 /**
- * 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.
+ * Backend that routes file operations to different backends based on path prefix.
  *
- * @param options - Configuration options
- * @returns AgentMiddleware for skills loading and injection
+ * This enables hybrid storage strategies like:
+ * - `/memories/` → StoreBackend (persistent, cross-thread)
+ * - Everything else → StateBackend (ephemeral, per-thread)
  *
- * @example
- * ```typescript
- * const middleware = createSkillsMiddleware({
- *   backend: new FilesystemBackend({ rootDir: "/" }),
- *   sources: ["/skills/user/", "/skills/project/"],
- * });
- * ```
- */
-declare function createSkillsMiddleware(options: SkillsMiddlewareOptions): AgentMiddleware<StateSchema<{
-  skillsMetadata: ReducedValue<{
-    name: string;
-    description: string;
-    path: string;
-    license?: string | null | undefined;
-    compatibility?: string | null | undefined;
-    metadata?: Record<string, string> | undefined;
-    allowedTools?: string[] | undefined;
-  }[] | undefined, {
-    name: string;
-    description: string;
-    path: string;
-    license?: string | null | undefined;
-    compatibility?: string | null | undefined;
-    metadata?: Record<string, string> | undefined;
-    allowedTools?: string[] | undefined;
-  }[] | undefined>;
-  files: ReducedValue<FilesRecord | undefined, FilesRecordUpdate | undefined>;
-}>, undefined, unknown, readonly (_langchain_core_tools0.ClientTool | _langchain_core_tools0.ServerTool)[]>;
-//#endregion
-//#region src/middleware/summarization.d.ts
-/**
- * Context size specification for summarization triggers and retention policies.
- */
-interface ContextSize {
-  /** Type of context measurement */
-  type: "messages" | "tokens" | "fraction";
-  /** Threshold value */
-  value: number;
-}
-/**
- * Settings for truncating large tool arguments in old messages.
+ * The CompositeBackend handles path prefix stripping/re-adding transparently.
  */
-interface TruncateArgsSettings {
-  /**
-   * Threshold to trigger argument truncation.
-   * If not provided, truncation is disabled.
-   */
-  trigger?: ContextSize;
+declare class CompositeBackend implements BackendProtocolV2 {
+  private default;
+  private routes;
+  private sortedRoutes;
+  constructor(defaultBackend: AnyBackendProtocol, routes: Record<string, AnyBackendProtocol>);
+  /** Delegates to default backend's id if it is a sandbox, otherwise empty string. */
+  get id(): string;
   /**
-   * Context retention policy for message truncation.
-   * Defaults to keeping last 20 messages.
+   * Determine which backend handles this key and strip prefix.
+   *
+   * @param key - Original file path
+   * @returns Tuple of [backend, stripped_key] where stripped_key has the route
+   *          prefix removed (but keeps leading slash).
    */
-  keep?: ContextSize;
+  private getBackendAndKey;
   /**
-   * Maximum character length for tool arguments before truncation.
-   * Defaults to 2000.
+   * List files and directories in the specified directory (non-recursive).
+   *
+   * @param path - Absolute path to directory
+   * @returns LsResult with list of FileInfo objects (with route prefixes added) on success or error on failure.
+   *          Directories have a trailing / in their path and is_dir=true.
    */
-  maxLength?: number;
+  ls(path: string): Promise<LsResult>;
   /**
-   * Text to replace truncated arguments with.
-   * Defaults to "...(argument truncated)".
+   * Read file content, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns Formatted file content with line numbers, or error message
    */
-  truncationText?: string;
-}
-/**
- * Options for the summarization middleware.
- */
-interface SummarizationMiddlewareOptions {
+  read(filePath: string, offset?: number, limit?: number): Promise<ReadResult>;
   /**
-   * The language model to use for generating summaries.
-   * Can be a model string (e.g., "gpt-4o-mini") or a language model instance.
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns ReadRawResult with raw file data on success or error on failure
    */
-  model: string | BaseChatModel | BaseLanguageModel;
+  readRaw(filePath: string): Promise<ReadRawResult>;
   /**
-   * Backend instance or factory for persisting conversation history.
+   * Structured search results or error string for invalid input.
    */
-  backend: BackendProtocol | BackendFactory | ((config: {
-    state: unknown;
-    store?: BaseStore;
-  }) => StateBackend);
+  grep(pattern: string, path?: string, glob?: string | null): Promise<GrepResult>;
   /**
-   * Threshold(s) that trigger summarization.
-   * Can be a single ContextSize or an array for multiple triggers.
+   * Structured glob matching returning FileInfo objects.
    */
-  trigger?: ContextSize | ContextSize[];
+  glob(pattern: string, path?: string): Promise<GlobResult>;
   /**
-   * Context retention policy after summarization.
-   * Defaults to keeping last 20 messages.
+   * Create a new file, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param content - File content as string
+   * @returns WriteResult with path or error
    */
-  keep?: ContextSize;
+  write(filePath: string, content: string): Promise<WriteResult>;
   /**
-   * Prompt template for generating summaries.
+   * Edit a file, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param oldString - String to find and replace
+   * @param newString - Replacement string
+   * @param replaceAll - If true, replace all occurrences
+   * @returns EditResult with path, occurrences, or error
    */
-  summaryPrompt?: string;
+  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
   /**
-   * Max tokens to include when generating summary.
-   * Defaults to 4000.
+   * Execute a command via the default backend.
+   * Execution is not path-specific, so it always delegates to the default backend.
+   *
+   * @param command - Full shell command string to execute
+   * @returns ExecuteResponse with combined output, exit code, and truncation flag
+   * @throws Error if the default backend doesn't support command execution
    */
-  trimTokensToSummarize?: number;
+  execute(command: string): Promise<ExecuteResponse>;
   /**
-   * Path prefix for storing conversation history.
-   * Defaults to "/conversation_history".
+   * Upload multiple files, batching by backend for efficiency.
+   *
+   * @param files - List of [path, content] tuples to upload
+   * @returns List of FileUploadResponse objects, one per input file
    */
-  historyPathPrefix?: string;
+  uploadFiles(files: Array<[string, Uint8Array]>): Promise<FileUploadResponse[]>;
   /**
-   * Settings for truncating large tool arguments in old messages.
-   * If not provided, argument truncation is disabled.
+   * Download multiple files, batching by backend for efficiency.
+   *
+   * @param paths - List of file paths to download
+   * @returns List of FileDownloadResponse objects, one per input path
    */
-  truncateArgsSettings?: TruncateArgsSettings;
+  downloadFiles(paths: string[]): Promise<FileDownloadResponse[]>;
 }
-/**
- * Compute summarization defaults based on model profile.
- * Mirrors Python's `_compute_summarization_defaults`.
- *
- * If the model has a profile with `maxInputTokens`, uses fraction-based
- * settings. Otherwise, uses fixed token/message counts.
- *
- * @param resolvedModel - The resolved chat model instance.
- */
-declare function computeSummarizationDefaults(resolvedModel: BaseChatModel): {
-  trigger: ContextSize;
-  keep: ContextSize;
-  truncateArgsSettings: TruncateArgsSettings;
-};
-/**
- * Create summarization middleware with backend support for conversation history offloading.
- *
- * This middleware:
- * 1. Monitors conversation length against configured thresholds
- * 2. When triggered, offloads old messages to backend storage
- * 3. Generates a summary of offloaded messages
- * 4. Replaces old messages with the summary, preserving recent context
- *
- * @param options - Configuration options
- * @returns AgentMiddleware for summarization and history offloading
- */
-declare function createSummarizationMiddleware(options: SummarizationMiddlewareOptions): AgentMiddleware<z$1.ZodObject<{
-  _summarizationSessionId: z$1.ZodOptional<z$1.ZodString>;
-  _summarizationEvent: z$1.ZodOptional<z$1.ZodObject<{
-    cutoffIndex: z$1.ZodNumber;
-    summaryMessage: z$1.ZodCustom<HumanMessage<_messages.MessageStructure<_messages.MessageToolSet>>, HumanMessage<_messages.MessageStructure<_messages.MessageToolSet>>>;
-    filePath: z$1.ZodNullable<z$1.ZodString>;
-  }, z$1.core.$strip>>;
-}, z$1.core.$strip>, undefined, unknown, readonly (ClientTool | ServerTool)[]>;
 //#endregion
-//#region src/backends/store.d.ts
+//#region src/backends/local-shell.d.ts
 /**
- * Options for StoreBackend constructor.
+ * Options for creating a LocalShellBackend instance.
  */
-interface StoreBackendOptions {
+interface LocalShellBackendOptions {
   /**
-   * Custom namespace for store operations.
-   *
-   * Determines where files are stored in the LangGraph store, enabling
-   * user-scoped, org-scoped, or any custom isolation pattern.
-   *
-   * If not provided, falls back to legacy behavior using assistantId from {@link BackendRuntime}.
-   *
-   * @example
-   * ```typescript
-   * // User-scoped storage
-   * new StoreBackend(runtime, {
-   *   namespace: ["memories", orgId, userId, "filesystem"],
-   * });
-   *
-   * // Org-scoped storage
-   * new StoreBackend(runtime, {
-   *   namespace: ["memories", orgId, "filesystem"],
-   * });
-   * ```
+   * Working directory for both filesystem operations and shell commands.
+   * @defaultValue `process.cwd()`
    */
-  namespace?: string[];
-}
-/**
- * Backend that stores files in LangGraph's BaseStore (persistent).
- *
- * Uses LangGraph's Store for persistent, cross-conversation storage.
- * Files are organized via namespaces and persist across all threads.
- *
- * The namespace can be customized via a factory function for flexible
- * isolation patterns (user-scoped, org-scoped, etc.), or falls back
- * to legacy assistant_id-based isolation.
- */
-declare class StoreBackend implements BackendProtocol {
-  private stateAndStore;
-  private _namespace;
-  constructor(stateAndStore: StateAndStore, options?: StoreBackendOptions);
+  rootDir?: string;
   /**
-   * Get the store instance.
-   *
-   * @returns BaseStore instance
-   * @throws Error if no store is available
+   * Enable virtual path mode for filesystem operations.
+   * When true, treats rootDir as a virtual root filesystem.
+   * Does NOT restrict shell commands.
+   * @defaultValue `false`
    */
-  private getStore;
+  virtualMode?: boolean;
   /**
-   * Get the namespace for store operations.
-   *
-   * If a custom namespace was provided, returns it directly.
-   *
-   * Otherwise, falls back to legacy behavior:
-   * - If assistantId is set: [assistantId, "filesystem"]
-   * - Otherwise: ["filesystem"]
+   * Maximum time in seconds to wait for shell command execution.
+   * Commands exceeding this timeout will be terminated.
+   * @defaultValue `120`
    */
-  protected getNamespace(): string[];
+  timeout?: number;
   /**
-   * Convert a store Item to FileData format.
-   *
-   * @param storeItem - The store Item containing file data
-   * @returns FileData object
-   * @throws Error if required fields are missing or have incorrect types
+   * Maximum number of bytes to capture from command output.
+   * Output exceeding this limit will be truncated.
+   * @defaultValue `100_000`
    */
-  private convertStoreItemToFileData;
+  maxOutputBytes?: number;
   /**
-   * Convert FileData to a value suitable for store.put().
-   *
-   * @param fileData - The FileData to convert
-   * @returns Object with content, created_at, and modified_at fields
+   * Environment variables for shell commands. If undefined, starts with an empty
+   * environment (unless inheritEnv is true).
+   * @defaultValue `undefined`
    */
-  private convertFileDataToStoreValue;
+  env?: Record<string, string>;
   /**
-   * Search store with automatic pagination to retrieve all results.
-   *
-   * @param store - The store to search
-   * @param namespace - Hierarchical path prefix to search within
-   * @param options - Optional query, filter, and page_size
-   * @returns List of all items matching the search criteria
+   * Whether to inherit the parent process's environment variables.
+   * When false, only variables in env dict are available.
+   * When true, inherits all process.env variables and applies env overrides.
+   * @defaultValue `false`
    */
-  private searchStorePaginated;
+  inheritEnv?: boolean;
   /**
-   * List files and directories in the specified directory (non-recursive).
-   *
-   * @param path - Absolute path to directory
-   * @returns List of FileInfo objects for files and directories directly in the directory.
-   *          Directories have a trailing / in their path and is_dir=true.
+   * Files to create on disk during `create()`.
+   * Keys are file paths (resolved via the backend's path handling),
+   * values are string content.
+   * @defaultValue `undefined`
    */
-  lsInfo(path: string): Promise<FileInfo[]>;
+  initialFiles?: Record<string, string>;
+}
+/**
+ * Filesystem backend with unrestricted local shell command execution.
+ *
+ * This backend extends FilesystemBackend to add shell command execution
+ * capabilities. Commands are executed directly on the host system without any
+ * sandboxing, process isolation, or security restrictions.
+ *
+ * **Security Warning:**
+ * This backend grants agents BOTH direct filesystem access AND unrestricted
+ * shell execution on your local machine. Use with extreme caution and only in
+ * appropriate environments.
+ *
+ * **Appropriate use cases:**
+ * - Local development CLIs (coding assistants, development tools)
+ * - Personal development environments where you trust the agent's code
+ * - CI/CD pipelines with proper secret management
+ *
+ * **Inappropriate use cases:**
+ * - Production environments (e.g., web servers, APIs, multi-tenant systems)
+ * - Processing untrusted user input or executing untrusted code
+ *
+ * Use StateBackend, StoreBackend, or extend BaseSandbox for production.
+ *
+ * @example
+ * ```typescript
+ * import { LocalShellBackend } from "@langchain/deepagents";
+ *
+ * // Create backend with explicit environment
+ * const backend = new LocalShellBackend({
+ *   rootDir: "/home/user/project",
+ *   env: { PATH: "/usr/bin:/bin" },
+ * });
+ *
+ * // Execute shell commands (runs directly on host)
+ * const result = await backend.execute("ls -la");
+ * console.log(result.output);
+ * console.log(result.exitCode);
+ *
+ * // Use filesystem operations (inherited from FilesystemBackend)
+ * const content = await backend.read("/README.md");
+ * await backend.write("/output.txt", "Hello world");
+ *
+ * // Inherit all environment variables
+ * const backend2 = new LocalShellBackend({
+ *   rootDir: "/home/user/project",
+ *   inheritEnv: true,
+ * });
+ * ```
+ */
+declare class LocalShellBackend extends FilesystemBackend implements SandboxBackendProtocolV2 {
+  #private;
+  constructor(options?: LocalShellBackendOptions);
+  /** Unique identifier for this backend instance (format: "local-{random_hex}"). */
+  get id(): string;
+  /** Whether the backend has been initialized and is ready to use. */
+  get isInitialized(): boolean;
+  /** Alias for `isInitialized`, matching the standard sandbox interface. */
+  get isRunning(): boolean;
   /**
-   * Read file content with line numbers.
+   * Initialize the backend by ensuring the rootDir exists.
    *
-   * @param filePath - Absolute file path
-   * @param offset - Line offset to start reading from (0-indexed)
-   * @param limit - Maximum number of lines to read
-   * @returns Formatted file content with line numbers, or error message
+   * Creates the rootDir (and any parent directories) if it does not already
+   * exist. Safe to call on an existing directory. Must be called before
+   * `execute()`, or use the static `LocalShellBackend.create()` factory.
+   *
+   * @throws {SandboxError} If already initialized (`ALREADY_INITIALIZED`)
    */
-  read(filePath: string, offset?: number, limit?: number): Promise<string>;
+  initialize(): Promise<void>;
   /**
-   * Read file content as raw FileData.
+   * Mark the backend as no longer running.
    *
-   * @param filePath - Absolute file path
-   * @returns Raw file content as FileData
+   * For local shell backends there is no remote resource to tear down,
+   * so this simply flips the `isRunning` / `isInitialized` flag.
    */
-  readRaw(filePath: string): Promise<FileData>;
+  close(): Promise<void>;
   /**
-   * Create a new file with content.
-   * Returns WriteResult. External storage sets filesUpdate=null.
+   * Read a file, adapting error messages to the standard sandbox format.
    */
-  write(filePath: string, content: string): Promise<WriteResult>;
+  read(filePath: string, offset?: number, limit?: number): Promise<ReadResult>;
   /**
-   * Edit a file by replacing string occurrences.
-   * Returns EditResult. External storage sets filesUpdate=null.
+   * Edit a file, adapting error messages to the standard sandbox format.
    */
   edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
   /**
-   * Structured search results or error string for invalid input.
+   * List directory contents, returning paths relative to rootDir.
    */
-  grepRaw(pattern: string, path?: string, glob?: string | null): Promise<GrepMatch[] | string>;
+  ls(dirPath: string): Promise<LsResult>;
   /**
-   * Structured glob matching returning FileInfo objects.
+   * Glob matching that returns relative paths and includes directories.
    */
-  globInfo(pattern: string, path?: string): Promise<FileInfo[]>;
+  glob(pattern: string, searchPath?: string): Promise<GlobResult>;
   /**
-   * Upload multiple files.
+   * Execute a shell command directly on the host system.
    *
-   * @param files - List of [path, content] tuples to upload
-   * @returns List of FileUploadResponse objects, one per input file
-   */
-  uploadFiles(files: Array<[string, Uint8Array]>): Promise<FileUploadResponse[]>;
-  /**
-   * Download multiple files.
+   * Commands are executed directly on your host system using `spawn()`
+   * with `shell: true`. There is NO sandboxing, isolation, or security
+   * restrictions. The command runs with your user's full permissions.
    *
-   * @param paths - List of file paths to download
-   * @returns List of FileDownloadResponse objects, one per input path
+   * The command is executed using the system shell with the working directory
+   * set to the backend's rootDir. Stdout and stderr are combined into a single
+   * output stream, with stderr lines prefixed with `[stderr]`.
+   *
+   * @param command - Shell command string to execute
+   * @returns ExecuteResponse containing output, exit code, and truncation flag
    */
-  downloadFiles(paths: string[]): Promise<FileDownloadResponse[]>;
+  execute(command: string): Promise<ExecuteResponse>;
+  /**
+   * Create and initialize a new LocalShellBackend in one step.
+   *
+   * This is the recommended way to create a backend when the rootDir may
+   * not exist yet. It combines construction and initialization (ensuring
+   * rootDir exists) into a single async operation.
+   *
+   * @param options - Configuration options for the backend
+   * @returns An initialized and ready-to-use backend
+   */
+  static create(options?: LocalShellBackendOptions): Promise<LocalShellBackend>;
 }
 //#endregion
-//#region src/backends/filesystem.d.ts
+//#region src/backends/sandbox.d.ts
 /**
- * Backend that reads and writes files directly from the filesystem.
+ * Base sandbox implementation with execute() as the only abstract method.
  *
- * Files are accessed using their actual filesystem paths. Relative paths are
- * resolved relative to the current working directory. Content is read/written
- * as plain text, and metadata (timestamps) are derived from filesystem stats.
+ * This class provides default implementations for all SandboxBackendProtocol
+ * methods using shell commands executed via execute(). Concrete implementations
+ * only need to implement execute(), uploadFiles(), and downloadFiles().
+ *
+ * All shell commands use pure POSIX utilities (awk, grep, find, stat) that are
+ * available on any Linux including Alpine/busybox. No Python, Node.js, or
+ * other runtime is required on the sandbox host.
  */
-declare class FilesystemBackend implements BackendProtocol {
-  protected cwd: string;
-  protected virtualMode: boolean;
-  private maxFileSizeBytes;
-  constructor(options?: {
-    rootDir?: string;
-    virtualMode?: boolean;
-    maxFileSizeMb?: number;
-  });
+declare abstract class BaseSandbox implements SandboxBackendProtocolV2 {
+  /** Unique identifier for the sandbox backend */
+  abstract readonly id: string;
   /**
-   * Resolve a file path with security checks.
-   *
-   * When virtualMode=true, treat incoming paths as virtual absolute paths under
-   * this.cwd, disallow traversal (.., ~) and ensure resolved path stays within root.
-   * When virtualMode=false, preserve legacy behavior: absolute paths are allowed
-   * as-is; relative paths resolve under cwd.
-   *
-   * @param key - File path (absolute, relative, or virtual when virtualMode=true)
-   * @returns Resolved absolute path string
-   * @throws Error if path traversal detected or path outside root
+   * Execute a command in the sandbox.
+   * This is the only method concrete implementations must provide.
    */
-  private resolvePath;
+  abstract execute(command: string): MaybePromise<ExecuteResponse>;
+  /**
+   * Upload multiple files to the sandbox.
+   * Implementations must support partial success.
+   */
+  abstract uploadFiles(files: Array<[string, Uint8Array]>): MaybePromise<FileUploadResponse[]>;
+  /**
+   * Download multiple files from the sandbox.
+   * Implementations must support partial success.
+   */
+  abstract downloadFiles(paths: string[]): MaybePromise<FileDownloadResponse[]>;
   /**
    * List files and directories in the specified directory (non-recursive).
    *
-   * @param dirPath - Absolute directory path to list files from
-   * @returns List of FileInfo objects for files and directories directly in the directory.
-   *          Directories have a trailing / in their path and is_dir=true.
+   * Uses pure POSIX shell (find + stat) via execute() — works on any Linux
+   * including Alpine. No Python or Node.js needed.
+   *
+   * @param path - Absolute path to directory
+   * @returns LsResult with list of FileInfo objects on success or error on failure.
    */
-  lsInfo(dirPath: string): Promise<FileInfo[]>;
+  ls(path: string): Promise<LsResult>;
   /**
    * Read file content with line numbers.
    *
-   * @param filePath - Absolute or relative file path
+   * Uses pure POSIX shell (awk) via execute() — only the requested slice
+   * is returned over the wire, making this efficient for large files.
+   * Works on any Linux including Alpine (no Python or Node.js needed).
+   *
+   * @param filePath - Absolute file path
    * @param offset - Line offset to start reading from (0-indexed)
    * @param limit - Maximum number of lines to read
    * @returns Formatted file content with line numbers, or error message
    */
-  read(filePath: string, offset?: number, limit?: number): Promise<string>;
+  read(filePath: string, offset?: number, limit?: number): Promise<ReadResult>;
   /**
    * Read file content as raw FileData.
    *
+   * Uses downloadFiles() directly — no runtime needed on the sandbox host.
+   *
    * @param filePath - Absolute file path
-   * @returns Raw file content as FileData
-   */
-  readRaw(filePath: string): Promise<FileData>;
-  /**
-   * Create a new file with content.
-   * Returns WriteResult. External storage sets filesUpdate=null.
+   * @returns ReadRawResult with raw file data on success or error on failure
    */
-  write(filePath: string, content: string): Promise<WriteResult>;
-  /**
-   * Edit a file by replacing string occurrences.
-   * Returns EditResult. External storage sets filesUpdate=null.
-   */
-  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
+  readRaw(filePath: string): Promise<ReadRawResult>;
   /**
-   * Search for a literal text pattern in files.
-   *
-   * Uses ripgrep if available, falling back to substring search.
+   * Search for a literal text pattern in files using grep.
    *
    * @param pattern - Literal string to search for (NOT regex).
-   * @param dirPath - Directory or file path to search in. Defaults to current directory.
+   * @param path - Directory or file path to search in.
    * @param glob - Optional glob pattern to filter which files to search.
    * @returns List of GrepMatch dicts containing path, line number, and matched text.
    */
-  grepRaw(pattern: string, dirPath?: string, glob?: string | null): Promise<GrepMatch[] | string>;
+  grep(pattern: string, path?: string, glob?: string | null): Promise<GrepResult>;
   /**
-   * Search using ripgrep with fixed-string (literal) mode.
+   * Structured glob matching returning FileInfo objects.
    *
-   * @param pattern - Literal string to search for (unescaped).
-   * @param baseFull - Resolved base path to search in.
-   * @param includeGlob - Optional glob pattern to filter files.
-   * @returns Dict mapping file paths to list of (line_number, line_text) tuples.
-   *          Returns null if ripgrep is unavailable or times out.
+   * Uses pure POSIX shell (find + stat) via execute() to list all files,
+   * then applies glob-to-regex matching in TypeScript. No Python or Node.js
+   * needed on the sandbox host.
+   *
+   * Glob patterns are matched against paths relative to the search base:
+   * - `*`  matches any characters except `/`
+   * - `**` matches any characters including `/` (recursive)
+   * - `?`  matches a single character except `/`
+   * - `[...]` character classes
    */
-  private ripgrepSearch;
+  glob(pattern: string, path?: string): Promise<GlobResult>;
   /**
-   * Fallback search using literal substring matching when ripgrep is unavailable.
+   * Create a new file with content.
    *
-   * Recursively searches files, respecting maxFileSizeBytes limit.
+   * Uses downloadFiles() to check existence and uploadFiles() to write.
+   * No runtime needed on the sandbox host.
+   */
+  write(filePath: string, content: string): Promise<WriteResult>;
+  /**
+   * Edit a file by replacing string occurrences.
    *
-   * @param pattern - Literal string to search for.
-   * @param baseFull - Resolved base path to search in.
-   * @param includeGlob - Optional glob pattern to filter files by name.
-   * @returns Dict mapping file paths to list of (line_number, line_text) tuples.
+   * Uses downloadFiles() to read, performs string replacement in TypeScript,
+   * then uploadFiles() to write back. No runtime needed on the sandbox host.
+   *
+   * Memory-conscious: releases intermediate references early so the GC can
+   * reclaim buffers before the next large allocation is made.
    */
-  private literalSearch;
+  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
+}
+//#endregion
+//#region src/backends/langsmith.d.ts
+/** Options for constructing a LangSmithSandbox from an existing Sandbox instance. */
+interface LangSmithSandboxOptions {
+  /** An already-created LangSmith Sandbox instance to wrap. */
+  sandbox: Sandbox;
   /**
-   * Structured glob matching returning FileInfo objects.
+   * Default command timeout in seconds.
+   * @default 1800 (30 minutes)
    */
-  globInfo(pattern: string, searchPath?: string): Promise<FileInfo[]>;
+  defaultTimeout?: number;
+}
+/** Options for the `LangSmithSandbox.create()` static factory. */
+interface LangSmithSandboxCreateOptions extends Omit<CreateSandboxOptions, "name" | "timeout" | "waitForReady"> {
   /**
-   * Upload multiple files to the filesystem.
-   *
-   * @param files - List of [path, content] tuples to upload
-   * @returns List of FileUploadResponse objects, one per input file
+   * Name of the LangSmith sandbox template to use.
+   * @default "deepagents"
    */
-  uploadFiles(files: Array<[string, Uint8Array]>): Promise<FileUploadResponse[]>;
+  templateName?: string;
   /**
-   * Download multiple files from the filesystem.
-   *
-   * @param paths - List of file paths to download
-   * @returns List of FileDownloadResponse objects, one per input path
+   * LangSmith API key. Defaults to the `LANGSMITH_API_KEY` environment variable.
    */
-  downloadFiles(paths: string[]): Promise<FileDownloadResponse[]>;
+  apiKey?: string;
+  /**
+   * Default command timeout in seconds.
+   * @default 1800 (30 minutes)
+   */
+  defaultTimeout?: number;
 }
-//#endregion
-//#region src/backends/composite.d.ts
 /**
- * Backend that routes file operations to different backends based on path prefix.
+ * LangSmith Sandbox backend for deepagents.
  *
- * This enables hybrid storage strategies like:
- * - `/memories/` → StoreBackend (persistent, cross-thread)
- * - Everything else → StateBackend (ephemeral, per-thread)
+ * Extends `BaseSandbox` to provide command execution and file operations
+ * via the LangSmith Sandbox API.
  *
- * The CompositeBackend handles path prefix stripping/re-adding transparently.
+ * Use the static `LangSmithSandbox.create()` factory for the simplest setup,
+ * or construct directly with an existing `Sandbox` instance.
  */
-declare class CompositeBackend implements BackendProtocol {
-  private default;
-  private routes;
-  private sortedRoutes;
-  constructor(defaultBackend: BackendProtocol, routes: Record<string, BackendProtocol>);
-  /** Delegates to default backend's id if it is a sandbox, otherwise empty string. */
+declare class LangSmithSandbox extends BaseSandbox {
+  #private;
+  constructor(options: LangSmithSandboxOptions);
+  /** Whether the sandbox is currently active. */
+  get isRunning(): boolean;
+  /** Return the LangSmith sandbox name as the unique identifier. */
   get id(): string;
   /**
-   * Determine which backend handles this key and strip prefix.
-   *
-   * @param key - Original file path
-   * @returns Tuple of [backend, stripped_key] where stripped_key has the route
-   *          prefix removed (but keeps leading slash).
-   */
-  private getBackendAndKey;
-  /**
-   * List files and directories in the specified directory (non-recursive).
-   *
-   * @param path - Absolute path to directory
-   * @returns List of FileInfo objects with route prefixes added, for files and directories
-   *          directly in the directory. Directories have a trailing / in their path and is_dir=true.
-   */
-  lsInfo(path: string): Promise<FileInfo[]>;
-  /**
-   * Read file content, routing to appropriate backend.
-   *
-   * @param filePath - Absolute file path
-   * @param offset - Line offset to start reading from (0-indexed)
-   * @param limit - Maximum number of lines to read
-   * @returns Formatted file content with line numbers, or error message
-   */
-  read(filePath: string, offset?: number, limit?: number): Promise<string>;
-  /**
-   * Read file content as raw FileData.
+   * Execute a shell command in the LangSmith sandbox.
    *
-   * @param filePath - Absolute file path
-   * @returns Raw file content as FileData
+   * @param command - Shell command string to execute
+   * @param options.timeout - Override timeout in seconds; 0 disables timeout
    */
-  readRaw(filePath: string): Promise<FileData>;
+  execute(command: string, options?: {
+    timeout?: number;
+  }): Promise<ExecuteResponse>;
   /**
-   * Structured search results or error string for invalid input.
+   * Download files from the sandbox using LangSmith's native file read API.
+   * @param paths - List of file paths to download
+   * @returns List of FileDownloadResponse objects, one per input path
    */
-  grepRaw(pattern: string, path?: string, glob?: string | null): Promise<GrepMatch[] | string>;
+  downloadFiles(paths: string[]): Promise<FileDownloadResponse[]>;
   /**
-   * Structured glob matching returning FileInfo objects.
+   * Upload files to the sandbox using LangSmith's native file write API.
+   * @param files - List of [path, content] tuples to upload
+   * @returns List of FileUploadResponse objects, one per input file
    */
-  globInfo(pattern: string, path?: string): Promise<FileInfo[]>;
+  uploadFiles(files: Array<[string, Uint8Array]>): Promise<FileUploadResponse[]>;
   /**
-   * Create a new file, routing to appropriate backend.
+   * Delete this sandbox and mark it as no longer running.
    *
-   * @param filePath - Absolute file path
-   * @param content - File content as string
-   * @returns WriteResult with path or error
+   * After calling this, `isRunning` will be `false` and the sandbox
+   * cannot be used again.
    */
-  write(filePath: string, content: string): Promise<WriteResult>;
+  close(): Promise<void>;
   /**
-   * Edit a file, routing to appropriate backend.
+   * Create and return a new LangSmithSandbox in one step.
    *
-   * @param filePath - Absolute file path
-   * @param oldString - String to find and replace
-   * @param newString - Replacement string
-   * @param replaceAll - If true, replace all occurrences
-   * @returns EditResult with path, occurrences, or error
-   */
-  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
-  /**
-   * Execute a command via the default backend.
-   * Execution is not path-specific, so it always delegates to the default backend.
+   * This is the recommended way to create a sandbox — no need to import
+   * anything from `langsmith/experimental/sandbox` directly.
    *
-   * @param command - Full shell command string to execute
-   * @returns ExecuteResponse with combined output, exit code, and truncation flag
-   * @throws Error if the default backend doesn't support command execution
-   */
-  execute(command: string): Promise<ExecuteResponse>;
-  /**
-   * Upload multiple files, batching by backend for efficiency.
-   *
-   * @param files - List of [path, content] tuples to upload
-   * @returns List of FileUploadResponse objects, one per input file
-   */
-  uploadFiles(files: Array<[string, Uint8Array]>): Promise<FileUploadResponse[]>;
-  /**
-   * Download multiple files, batching by backend for efficiency.
-   *
-   * @param paths - List of file paths to download
-   * @returns List of FileDownloadResponse objects, one per input path
+   * @example
+   * ```typescript
+   * const sandbox = await LangSmithSandbox.create({ templateName: "deepagents" });
+   * try {
+   *   const agent = createDeepAgent({ model, backend: sandbox });
+   *   await agent.invoke({ messages: [...] });
+   * } finally {
+   *   await sandbox.close();
+   * }
+   * ```
    */
-  downloadFiles(paths: string[]): Promise<FileDownloadResponse[]>;
+  static create(options?: LangSmithSandboxCreateOptions): Promise<LangSmithSandbox>;
 }
 //#endregion
-//#region src/backends/local-shell.d.ts
+//#region src/backends/utils.d.ts
 /**
- * Options for creating a LocalShellBackend instance.
+ * Adapt a v1 {@link BackendProtocol} to {@link BackendProtocolV2}.
+ *
+ * If the backend already implements v2, it is returned as-is.
+ * For v1 backends, wraps returns in Result types:
+ * - `read()` string returns wrapped in {@link ReadResult}
+ * - `readRaw()` FileData returns wrapped in {@link ReadRawResult}
+ * - `grep()` returns wrapped in {@link GrepResult}
+ * - `ls()` FileInfo[] returns wrapped in {@link LsResult}
+ * - `glob()` FileInfo[] returns wrapped in {@link GlobResult}
+ *
+ * Note: For sandbox instances, use {@link adaptSandboxProtocol} instead.
+ *
+ * @param backend - Backend instance (v1 or v2)
+ * @returns BackendProtocolV2-compatible backend
  */
-interface LocalShellBackendOptions {
-  /**
-   * Working directory for both filesystem operations and shell commands.
-   * @defaultValue `process.cwd()`
-   */
-  rootDir?: string;
-  /**
-   * Enable virtual path mode for filesystem operations.
-   * When true, treats rootDir as a virtual root filesystem.
-   * Does NOT restrict shell commands.
-   * @defaultValue `false`
-   */
-  virtualMode?: boolean;
-  /**
-   * Maximum time in seconds to wait for shell command execution.
-   * Commands exceeding this timeout will be terminated.
-   * @defaultValue `120`
-   */
-  timeout?: number;
-  /**
-   * Maximum number of bytes to capture from command output.
-   * Output exceeding this limit will be truncated.
-   * @defaultValue `100_000`
-   */
-  maxOutputBytes?: number;
-  /**
-   * Environment variables for shell commands. If undefined, starts with an empty
-   * environment (unless inheritEnv is true).
-   * @defaultValue `undefined`
-   */
-  env?: Record<string, string>;
+declare function adaptBackendProtocol(backend: AnyBackendProtocol): BackendProtocolV2;
+/**
+ * Adapt a sandbox backend from v1 to v2 interface.
+ *
+ * This extends {@link adaptBackendProtocol} to also preserve sandbox-specific
+ * properties from {@link SandboxBackendProtocol}: `execute` and `id`.
+ *
+ * @param sandbox - Sandbox backend (v1 or v2)
+ * @returns SandboxBackendProtocolV2-compatible sandbox
+ */
+declare function adaptSandboxProtocol(sandbox: AnySandboxProtocol): SandboxBackendProtocolV2;
+//#endregion
+//#region src/middleware/subagents.d.ts
+/**
+ * Default system prompt for subagents.
+ * Provides a minimal base prompt that can be extended by specific subagent configurations.
+ */
+declare const DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
+/**
+ * Default description for the general-purpose subagent.
+ * This description is shown to the model when selecting which subagent to use.
+ */
+declare 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.";
+/**
+ * System prompt section that explains how to use the task tool for spawning subagents.
+ *
+ * This prompt is automatically appended to the main agent's system prompt when
+ * using `createSubAgentMiddleware`. It provides guidance on:
+ * - When to use the task tool
+ * - Subagent lifecycle (spawn → run → return → reconcile)
+ * - When NOT to use the task tool
+ * - Best practices for parallel task execution
+ *
+ * You can provide a custom `systemPrompt` to `createSubAgentMiddleware` to override
+ * or extend this default.
+ */
+declare const TASK_SYSTEM_PROMPT: string;
+/**
+ * Type definitions for pre-compiled agents.
+ *
+ * @typeParam TRunnable - The type of the runnable (ReactAgent or Runnable).
+ *   When using `createAgent` or `createDeepAgent`, this preserves the middleware
+ *   types for type inference. Uses `ReactAgent<any>` to accept agents with any
+ *   type configuration (including DeepAgent instances).
+ */
+interface CompiledSubAgent<TRunnable extends ReactAgent<any> | Runnable = ReactAgent<any> | Runnable> {
+  /** The name of the agent */
+  name: string;
+  /** The description of the agent */
+  description: string;
+  /** The agent instance */
+  runnable: TRunnable;
+}
+/**
+ * Specification for a subagent that can be dynamically created.
+ *
+ * When using `createDeepAgent`, subagents automatically receive a default middleware
+ * stack (todoListMiddleware, filesystemMiddleware, summarizationMiddleware, etc.) before
+ * any custom `middleware` specified in this spec.
+ *
+ * Required fields:
+ * - `name`: Identifier used to select this subagent in the task tool
+ * - `description`: Shown to the model for subagent selection
+ * - `systemPrompt`: The system prompt for the subagent
+ *
+ * Optional fields:
+ * - `model`: Override the default model for this subagent
+ * - `tools`: Override the default tools for this subagent
+ * - `middleware`: Additional middleware appended after defaults
+ * - `interruptOn`: Human-in-the-loop configuration for specific tools
+ * - `skills`: Skill source paths for SkillsMiddleware (e.g., `["/skills/user/", "/skills/project/"]`)
+ *
+ * @example
+ * ```typescript
+ * const researcher: SubAgent = {
+ *   name: "researcher",
+ *   description: "Research assistant for complex topics",
+ *   systemPrompt: "You are a research assistant.",
+ *   tools: [webSearchTool],
+ *   skills: ["/skills/research/"],
+ * };
+ * ```
+ */
+interface SubAgent {
+  /** Identifier used to select this subagent in the task tool */
+  name: string;
+  /** Description shown to the model for subagent selection */
+  description: string;
+  /** The system prompt to use for the agent */
+  systemPrompt: string;
+  /** The tools to use for the agent (tool instances, not names). Defaults to defaultTools */
+  tools?: StructuredTool[];
+  /** The model for the agent. Defaults to defaultModel */
+  model?: LanguageModelLike | string;
+  /** Additional middleware to append after default_middleware */
+  middleware?: readonly AgentMiddleware$1[];
+  /** Human-in-the-loop configuration for specific tools. Requires a checkpointer. */
+  interruptOn?: Record<string, boolean | InterruptOnConfig>;
   /**
-   * Whether to inherit the parent process's environment variables.
-   * When false, only variables in env dict are available.
-   * When true, inherits all process.env variables and applies env overrides.
-   * @defaultValue `false`
+   * Skill source paths for SkillsMiddleware.
+   *
+   * List of paths to skill directories (e.g., `["/skills/user/", "/skills/project/"]`).
+   * When specified, the subagent will have its own SkillsMiddleware that loads skills
+   * from these paths. This allows subagents to have different skill sets than the main agent.
+   *
+   * Note: Custom subagents do NOT inherit skills from the main agent by default.
+   * Only the general-purpose subagent inherits the main agent's skills.
+   *
+   * @example
+   * ```typescript
+   * const researcher: SubAgent = {
+   *   name: "researcher",
+   *   description: "Research assistant",
+   *   systemPrompt: "You are a researcher.",
+   *   skills: ["/skills/research/", "/skills/web-search/"],
+   * };
+   * ```
    */
-  inheritEnv?: boolean;
+  skills?: string[];
   /**
-   * Files to create on disk during `create()`.
-   * Keys are file paths (resolved via the backend's path handling),
-   * values are string content.
-   * @defaultValue `undefined`
+   * Structured output response format for the subagent.
+   *
+   * When specified, the subagent will produce a `structuredResponse` conforming to the
+   * given schema. The structured response is JSON-serialized and returned as the
+   * ToolMessage content to the parent agent, replacing the default last-message extraction.
+   *
+   * Accepts any format supported by `createAgent`: Zod schemas, JSON schema objects,
+   * `toolStrategy(schema)`, `providerStrategy(schema)`, etc.
+   *
+   * @example
+   * ```typescript
+   * import { z } from "zod"
+   *
+   * const analyzer: SubAgent = {
+   *   name: "analyzer",
+   *   description: "Analyzes data and returns structured findings",
+   *   systemPrompt: "Analyze the data and return your findings.",
+   *   responseFormat: z.object({
+   *     findings: z.string(),
+   *     confidence: z.number(),
+   *   }),
+   * };
+   * ```
    */
-  initialFiles?: Record<string, string>;
+  responseFormat?: CreateAgentParams["responseFormat"];
 }
 /**
- * Filesystem backend with unrestricted local shell command execution.
- *
- * This backend extends FilesystemBackend to add shell command execution
- * capabilities. Commands are executed directly on the host system without any
- * sandboxing, process isolation, or security restrictions.
- *
- * **Security Warning:**
- * This backend grants agents BOTH direct filesystem access AND unrestricted
- * shell execution on your local machine. Use with extreme caution and only in
- * appropriate environments.
+ * Base specification for the general-purpose subagent.
  *
- * **Appropriate use cases:**
- * - Local development CLIs (coding assistants, development tools)
- * - Personal development environments where you trust the agent's code
- * - CI/CD pipelines with proper secret management
+ * This constant provides the default configuration for the general-purpose subagent
+ * that is automatically included when `generalPurposeAgent: true` (the default).
  *
- * **Inappropriate use cases:**
- * - Production environments (e.g., web servers, APIs, multi-tenant systems)
- * - Processing untrusted user input or executing untrusted code
+ * The general-purpose subagent:
+ * - Has access to all tools from the main agent
+ * - Inherits skills from the main agent (when skills are configured)
+ * - Uses the same model as the main agent (by default)
+ * - Is ideal for delegating complex, multi-step tasks
  *
- * Use StateBackend, StoreBackend, or extend BaseSandbox for production.
+ * You can spread this constant and override specific properties when creating
+ * custom subagents that should behave similarly to the general-purpose agent:
  *
  * @example
  * ```typescript
- * import { LocalShellBackend } from "@langchain/deepagents";
+ * import { GENERAL_PURPOSE_SUBAGENT, createDeepAgent } from "@anthropic/deepagents";
  *
- * // Create backend with explicit environment
- * const backend = new LocalShellBackend({
- *   rootDir: "/home/user/project",
- *   env: { PATH: "/usr/bin:/bin" },
+ * // Use as-is (automatically included with generalPurposeAgent: true)
+ * const agent = createDeepAgent({ model: "claude-sonnet-4-5-20250929" });
+ *
+ * // Or create a custom variant with different tools
+ * const customGP: SubAgent = {
+ *   ...GENERAL_PURPOSE_SUBAGENT,
+ *   name: "research-gp",
+ *   tools: [webSearchTool, readFileTool],
+ * };
+ *
+ * const agent = createDeepAgent({
+ *   model: "claude-sonnet-4-5-20250929",
+ *   subagents: [customGP],
+ *   // Disable the default general-purpose agent since we're providing our own
+ *   // (handled automatically when using createSubAgentMiddleware directly)
  * });
+ * ```
+ */
+declare const GENERAL_PURPOSE_SUBAGENT: Pick<SubAgent, "name" | "description" | "systemPrompt">;
+/**
+ * Options for creating subagent middleware
+ */
+interface SubAgentMiddlewareOptions {
+  /** The model to use for subagents */
+  defaultModel: LanguageModelLike | string;
+  /** The tools to use for the default general-purpose subagent */
+  defaultTools?: StructuredTool[];
+  /** Default middleware to apply to custom subagents (WITHOUT skills from main agent) */
+  defaultMiddleware?: AgentMiddleware$1[] | null;
+  /**
+   * Middleware specifically for the general-purpose subagent (includes skills from main agent).
+   * If not provided, falls back to defaultMiddleware.
+   */
+  generalPurposeMiddleware?: AgentMiddleware$1[] | null;
+  /** The tool configs for the default general-purpose subagent */
+  defaultInterruptOn?: Record<string, boolean | InterruptOnConfig> | null;
+  /** A list of additional subagents to provide to the agent */
+  subagents?: (SubAgent | CompiledSubAgent)[];
+  /** Full system prompt override */
+  systemPrompt?: string | null;
+  /** Whether to include the general-purpose agent */
+  generalPurposeAgent?: boolean;
+  /** Custom description for the task tool */
+  taskDescription?: string | null;
+}
+/**
+ * Create subagent middleware with task tool
+ */
+declare function createSubAgentMiddleware(options: SubAgentMiddlewareOptions): AgentMiddleware$1<undefined, undefined, unknown, readonly [_langchain.DynamicStructuredTool<z.ZodObject<{
+  description: z.ZodString;
+  subagent_type: z.ZodString;
+}, z.core.$strip>, {
+  description: string;
+  subagent_type: string;
+}, {
+  description: string;
+  subagent_type: string;
+}, string | Command<unknown, Record<string, unknown>, string>, unknown, "task">]>;
+//#endregion
+//#region src/middleware/patch_tool_calls.d.ts
+/**
+ * Create middleware that enforces strict tool call / tool response parity in
+ * the messages history.
+ *
+ * Two kinds of violations are repaired:
+ * 1. **Dangling tool_calls** — an AIMessage contains tool_calls with no
+ *    matching ToolMessage responses. Synthetic cancellation ToolMessages are
+ *    injected so every tool_call has a response.
+ * 2. **Orphaned ToolMessages** — a ToolMessage exists whose `tool_call_id`
+ *    does not match any tool_call in a preceding AIMessage. These are removed.
+ *
+ * This is critical for providers like Google Gemini that reject requests with
+ * mismatched function call / function response counts (400 INVALID_ARGUMENT).
+ *
+ * This middleware patches in two places:
+ * 1. `beforeAgent`: Patches state at the start of the agent loop (handles most cases)
+ * 2. `wrapModelCall`: Patches the request right before model invocation (handles
+ *    edge cases like HITL rejection during graph resume where state updates from
+ *    beforeAgent may not be applied in time)
  *
- * // Execute shell commands (runs directly on host)
- * const result = await backend.execute("ls -la");
- * console.log(result.output);
- * console.log(result.exitCode);
+ * @returns AgentMiddleware that enforces tool call / response parity
  *
- * // Use filesystem operations (inherited from FilesystemBackend)
- * const content = await backend.read("/README.md");
- * await backend.write("/output.txt", "Hello world");
+ * @example
+ * ```typescript
+ * import { createAgent } from "langchain";
+ * import { createPatchToolCallsMiddleware } from "./middleware/patch_tool_calls";
  *
- * // Inherit all environment variables
- * const backend2 = new LocalShellBackend({
- *   rootDir: "/home/user/project",
- *   inheritEnv: true,
+ * const agent = createAgent({
+ *   model: "claude-sonnet-4-5-20250929",
+ *   middleware: [createPatchToolCallsMiddleware()],
  * });
  * ```
  */
-declare class LocalShellBackend extends FilesystemBackend implements SandboxBackendProtocol {
-  #private;
-  constructor(options?: LocalShellBackendOptions);
-  /** Unique identifier for this backend instance (format: "local-{random_hex}"). */
-  get id(): string;
-  /** Whether the backend has been initialized and is ready to use. */
-  get isInitialized(): boolean;
-  /** Alias for `isInitialized`, matching the standard sandbox interface. */
-  get isRunning(): boolean;
-  /**
-   * Initialize the backend by ensuring the rootDir exists.
-   *
-   * Creates the rootDir (and any parent directories) if it does not already
-   * exist. Safe to call on an existing directory. Must be called before
-   * `execute()`, or use the static `LocalShellBackend.create()` factory.
-   *
-   * @throws {SandboxError} If already initialized (`ALREADY_INITIALIZED`)
-   */
-  initialize(): Promise<void>;
-  /**
-   * Mark the backend as no longer running.
-   *
-   * For local shell backends there is no remote resource to tear down,
-   * so this simply flips the `isRunning` / `isInitialized` flag.
-   */
-  close(): Promise<void>;
-  /**
-   * Read a file, adapting error messages to the standard sandbox format.
-   */
-  read(filePath: string, offset?: number, limit?: number): Promise<string>;
-  /**
-   * Edit a file, adapting error messages to the standard sandbox format.
-   */
-  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
-  /**
-   * List directory contents, returning paths relative to rootDir.
-   */
-  lsInfo(dirPath: string): Promise<FileInfo[]>;
+declare function createPatchToolCallsMiddleware(): AgentMiddleware<undefined, undefined, unknown, readonly (_$_langchain_core_tools0.ClientTool | _$_langchain_core_tools0.ServerTool)[]>;
+//#endregion
+//#region src/middleware/memory.d.ts
+/**
+ * Options for the memory middleware.
+ */
+interface MemoryMiddlewareOptions {
   /**
-   * Glob matching that returns relative paths and includes directories.
+   * Backend instance or factory function for file operations.
+   * Use a factory for StateBackend since it requires runtime state.
    */
-  globInfo(pattern: string, searchPath?: string): Promise<FileInfo[]>;
+  backend: AnyBackendProtocol | BackendFactory | ((config: {
+    state: unknown;
+    store?: BaseStore;
+  }) => StateBackend);
   /**
-   * Execute a shell command directly on the host system.
-   *
-   * Commands are executed directly on your host system using `spawn()`
-   * with `shell: true`. There is NO sandboxing, isolation, or security
-   * restrictions. The command runs with your user's full permissions.
-   *
-   * The command is executed using the system shell with the working directory
-   * set to the backend's rootDir. Stdout and stderr are combined into a single
-   * output stream, with stderr lines prefixed with `[stderr]`.
-   *
-   * @param command - Shell command string to execute
-   * @returns ExecuteResponse containing output, exit code, and truncation flag
+   * List of memory file paths to load (e.g., ["~/.deepagents/AGENTS.md", "./.deepagents/AGENTS.md"]).
+   * Display names are automatically derived from the paths.
+   * Sources are loaded in order.
    */
-  execute(command: string): Promise<ExecuteResponse>;
+  sources: string[];
   /**
-   * Create and initialize a new LocalShellBackend in one step.
-   *
-   * This is the recommended way to create a backend when the rootDir may
-   * not exist yet. It combines construction and initialization (ensuring
-   * rootDir exists) into a single async operation.
-   *
-   * @param options - Configuration options for the backend
-   * @returns An initialized and ready-to-use backend
+   * Whether to add cache_control breakpoints to the memory content block.
+   * When true, the memory block is tagged with `cache_control: { type: "ephemeral" }`
+   * to enable prompt caching for providers that support it (e.g., Anthropic).
+   * @default false
    */
-  static create(options?: LocalShellBackendOptions): Promise<LocalShellBackend>;
+  addCacheControl?: boolean;
 }
-//#endregion
-//#region src/backends/sandbox.d.ts
 /**
- * Base sandbox implementation with execute() as the only abstract method.
+ * Create middleware for loading agent memory from AGENTS.md files.
  *
- * This class provides default implementations for all SandboxBackendProtocol
- * methods using shell commands executed via execute(). Concrete implementations
- * only need to implement execute(), uploadFiles(), and downloadFiles().
+ * Loads memory content from configured sources and injects into the system prompt.
+ * Supports multiple sources that are combined together.
  *
- * All shell commands use pure POSIX utilities (awk, grep, find, stat) that are
- * available on any Linux including Alpine/busybox. No Python, Node.js, or
- * other runtime is required on the sandbox host.
+ * @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",
+ *   ],
+ * });
+ * ```
  */
-declare abstract class BaseSandbox implements SandboxBackendProtocol {
-  /** Unique identifier for the sandbox backend */
-  abstract readonly id: string;
+declare function createMemoryMiddleware(options: MemoryMiddlewareOptions): AgentMiddleware<StateSchema<{
   /**
-   * Execute a command in the sandbox.
-   * This is the only method concrete implementations must provide.
+   * Dict mapping source paths to their loaded content.
+   * Marked as private so it's not included in the final agent state.
    */
-  abstract execute(command: string): MaybePromise<ExecuteResponse>;
+  memoryContents: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+  files: _langgraph.ReducedValue<FilesRecord | undefined, FilesRecordUpdate | undefined>;
+}>, undefined, unknown, readonly (_$_langchain_core_tools0.ClientTool | _$_langchain_core_tools0.ServerTool)[]>;
+//#endregion
+//#region src/middleware/skills.d.ts
+declare const MAX_SKILL_FILE_SIZE: number;
+declare const MAX_SKILL_NAME_LENGTH = 64;
+declare const MAX_SKILL_DESCRIPTION_LENGTH = 1024;
+/**
+ * Metadata for a skill per Agent Skills specification.
+ */
+interface SkillMetadata$1 {
   /**
-   * Upload multiple files to the sandbox.
-   * Implementations must support partial success.
+   * Skill identifier.
+   *
+   * Constraints per Agent Skills specification:
+   *
+   * - 1-64 characters
+   * - Unicode lowercase alphanumeric and hyphens only (`a-z` and `-`).
+   * - Must not start or end with `-`
+   * - Must not contain consecutive `--`
+   * - Must match the parent directory name containing the `SKILL.md` file
    */
-  abstract uploadFiles(files: Array<[string, Uint8Array]>): MaybePromise<FileUploadResponse[]>;
+  name: string;
   /**
-   * Download multiple files from the sandbox.
-   * Implementations must support partial success.
+   * What the skill does.
+   *
+   * Constraints per Agent Skills specification:
+   *
+   * - 1-1024 characters
+   * - Should describe both what the skill does and when to use it
+   * - Should include specific keywords that help agents identify relevant tasks
    */
-  abstract downloadFiles(paths: string[]): MaybePromise<FileDownloadResponse[]>;
+  description: string;
+  /** Path to the SKILL.md file in the backend */
+  path: string;
+  /** License name or reference to bundled license file. */
+  license?: string | null;
   /**
-   * List files and directories in the specified directory (non-recursive).
+   * Environment requirements.
    *
-   * Uses pure POSIX shell (find + stat) via execute() — works on any Linux
-   * including Alpine. No Python or Node.js needed.
+   * Constraints per Agent Skills specification:
    *
-   * @param path - Absolute path to directory
-   * @returns List of FileInfo objects for files and directories directly in the directory.
+   * - 1-500 characters if provided
+   * - Should only be included if there are specific compatibility requirements
+   * - Can indicate intended product, required packages, etc.
    */
-  lsInfo(path: string): Promise<FileInfo[]>;
+  compatibility?: string | null;
   /**
-   * Read file content with line numbers.
+   * Arbitrary key-value mapping for additional metadata.
    *
-   * Uses pure POSIX shell (awk) via execute() — only the requested slice
-   * is returned over the wire, making this efficient for large files.
-   * Works on any Linux including Alpine (no Python or Node.js needed).
+   * Clients can use this to store additional properties not defined by the spec.
    *
-   * @param filePath - Absolute file path
-   * @param offset - Line offset to start reading from (0-indexed)
-   * @param limit - Maximum number of lines to read
-   * @returns Formatted file content with line numbers, or error message
+   * It is recommended to keep key names unique to avoid conflicts.
    */
-  read(filePath: string, offset?: number, limit?: number): Promise<string>;
+  metadata?: Record<string, string>;
   /**
-   * Read file content as raw FileData.
+   * Tool names the skill recommends using.
    *
-   * Uses downloadFiles() directly — no runtime needed on the sandbox host.
+   * Warning: this is experimental.
    *
-   * @param filePath - Absolute file path
-   * @returns Raw file content as FileData
+   * Constraints per Agent Skills specification:
+   *
+   * - Space-delimited list of tool names
    */
-  readRaw(filePath: string): Promise<FileData>;
+  allowedTools?: string[];
+}
+/**
+ * Options for the skills middleware.
+ */
+interface SkillsMiddlewareOptions {
   /**
-   * Search for a literal text pattern in files using grep.
-   *
-   * @param pattern - Literal string to search for (NOT regex).
-   * @param path - Directory or file path to search in.
-   * @param glob - Optional glob pattern to filter which files to search.
-   * @returns List of GrepMatch dicts containing path, line number, and matched text.
+   * Backend instance or factory function for file operations.
+   * Use a factory for StateBackend since it requires runtime state.
+   */
+  backend: AnyBackendProtocol | BackendFactory | ((config: {
+    state: unknown;
+    store?: BaseStore;
+  }) => StateBackend);
+  /**
+   * List of skill source paths to load (e.g., ["/skills/user/", "/skills/project/"]).
+   * Paths must use POSIX conventions (forward slashes).
+   * Later sources override earlier ones for skills with the same name (last one wins).
    */
-  grepRaw(pattern: string, path?: string, glob?: string | null): Promise<GrepMatch[] | string>;
+  sources: string[];
+}
+/**
+ * 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/"],
+ * });
+ * ```
+ */
+declare function createSkillsMiddleware(options: SkillsMiddlewareOptions): AgentMiddleware<StateSchema<{
+  skillsMetadata: ReducedValue<{
+    name: string;
+    description: string;
+    path: string;
+    license?: string | null | undefined;
+    compatibility?: string | null | undefined;
+    metadata?: Record<string, string> | undefined;
+    allowedTools?: string[] | undefined;
+  }[] | undefined, {
+    name: string;
+    description: string;
+    path: string;
+    license?: string | null | undefined;
+    compatibility?: string | null | undefined;
+    metadata?: Record<string, string> | undefined;
+    allowedTools?: string[] | undefined;
+  }[] | undefined>;
+  files: ReducedValue<FilesRecord | undefined, FilesRecordUpdate | undefined>;
+}>, undefined, unknown, readonly (_$_langchain_core_tools0.ClientTool | _$_langchain_core_tools0.ServerTool)[]>;
+//#endregion
+//#region src/middleware/completion_callback.d.ts
+/**
+ * Options for creating the completion callback middleware.
+ */
+interface CompletionCallbackOptions {
   /**
-   * Structured glob matching returning FileInfo objects.
-   *
-   * Uses pure POSIX shell (find + stat) via execute() to list all files,
-   * then applies glob-to-regex matching in TypeScript. No Python or Node.js
-   * needed on the sandbox host.
-   *
-   * Glob patterns are matched against paths relative to the search base:
-   * - `*`  matches any characters except `/`
-   * - `**` matches any characters including `/` (recursive)
-   * - `?`  matches a single character except `/`
-   * - `[...]` character classes
+   * Callback graph or assistant identifier. Used as the `assistant_id`
+   * argument in `runs.create()`.
    */
-  globInfo(pattern: string, path?: string): Promise<FileInfo[]>;
+  callbackGraphId: string;
   /**
-   * Create a new file with content.
-   *
-   * Uses downloadFiles() to check existence and uploadFiles() to write.
-   * No runtime needed on the sandbox host.
+   * URL of the callback LangGraph server. Omit to use same-deployment
+   * ASGI transport.
    */
-  write(filePath: string, content: string): Promise<WriteResult>;
+  url?: string;
   /**
-   * Edit a file by replacing string occurrences.
-   *
-   * Uses downloadFiles() to read, performs string replacement in TypeScript,
-   * then uploadFiles() to write back. No runtime needed on the sandbox host.
-   *
-   * Memory-conscious: releases intermediate references early so the GC can
-   * reclaim buffers before the next large allocation is made.
+   * Additional headers to include in requests to the callback server.
    */
-  edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
+  headers?: Record<string, string>;
 }
+/**
+ * Create a completion callback middleware for async subagents.
+ *
+ * **Experimental** — this middleware is experimental and may change.
+ *
+ * This middleware is added to a subagent's middleware stack. On success or
+ * model-call error, it sends a notification to the configured callback
+ * thread by calling `runs.create()`.
+ *
+ * The callback destination is configured with `callbackGraphId` and
+ * optional `url` and `headers`. The target thread is read from
+ * `callbackThreadId` in the subagent state.
+ *
+ * If `callbackThreadId` is not present in state, the middleware does
+ * nothing.
+ *
+ * @param options - Configuration options.
+ * @returns An `AgentMiddleware` instance.
+ *
+ * @example
+ * ```typescript
+ * import { createCompletionCallbackMiddleware } from "deepagents";
+ *
+ * const notifier = createCompletionCallbackMiddleware({
+ *   callbackGraphId: "supervisor",
+ * });
+ *
+ * const agent = createDeepAgent({
+ *   model: "claude-sonnet-4-5-20250929",
+ *   middleware: [notifier],
+ * });
+ * ```
+ */
+declare function createCompletionCallbackMiddleware(options: CompletionCallbackOptions): AgentMiddleware<z$2.ZodObject<{
+  callbackThreadId: z$2.ZodOptional<z$2.ZodString>;
+}, z$2.core.$strip>, undefined, unknown, readonly (_$_langchain_core_tools0.ClientTool | _$_langchain_core_tools0.ServerTool)[]>;
 //#endregion
-//#region src/backends/langsmith.d.ts
-/** Options for constructing a LangSmithSandbox from an existing Sandbox instance. */
-interface LangSmithSandboxOptions {
-  /** An already-created LangSmith Sandbox instance to wrap. */
-  sandbox: Sandbox;
+//#region src/middleware/summarization.d.ts
+/**
+ * Context size specification for summarization triggers and retention policies.
+ */
+interface ContextSize {
+  /** Type of context measurement */
+  type: "messages" | "tokens" | "fraction";
+  /** Threshold value */
+  value: number;
+}
+/**
+ * Settings for truncating large tool arguments in old messages.
+ */
+interface TruncateArgsSettings {
   /**
-   * Default command timeout in seconds.
-   * @default 1800 (30 minutes)
+   * Threshold to trigger argument truncation.
+   * If not provided, truncation is disabled.
    */
-  defaultTimeout?: number;
-}
-/** Options for the `LangSmithSandbox.create()` static factory. */
-interface LangSmithSandboxCreateOptions extends Omit<CreateSandboxOptions, "name" | "timeout" | "waitForReady"> {
+  trigger?: ContextSize;
   /**
-   * Name of the LangSmith sandbox template to use.
-   * @default "deepagents"
+   * Context retention policy for message truncation.
+   * Defaults to keeping last 20 messages.
    */
-  templateName?: string;
+  keep?: ContextSize;
   /**
-   * LangSmith API key. Defaults to the `LANGSMITH_API_KEY` environment variable.
+   * Maximum character length for tool arguments before truncation.
+   * Defaults to 2000.
    */
-  apiKey?: string;
+  maxLength?: number;
   /**
-   * Default command timeout in seconds.
-   * @default 1800 (30 minutes)
+   * Text to replace truncated arguments with.
+   * Defaults to "...(argument truncated)".
    */
-  defaultTimeout?: number;
+  truncationText?: string;
 }
 /**
- * LangSmith Sandbox backend for deepagents.
- *
- * Extends `BaseSandbox` to provide command execution and file operations
- * via the LangSmith Sandbox API.
- *
- * Use the static `LangSmithSandbox.create()` factory for the simplest setup,
- * or construct directly with an existing `Sandbox` instance.
+ * Options for the summarization middleware.
  */
-declare class LangSmithSandbox extends BaseSandbox {
-  #private;
-  constructor(options: LangSmithSandboxOptions);
-  /** Whether the sandbox is currently active. */
-  get isRunning(): boolean;
-  /** Return the LangSmith sandbox name as the unique identifier. */
-  get id(): string;
+interface SummarizationMiddlewareOptions {
   /**
-   * Execute a shell command in the LangSmith sandbox.
-   *
-   * @param command - Shell command string to execute
-   * @param options.timeout - Override timeout in seconds; 0 disables timeout
+   * The language model to use for generating summaries.
+   * Can be a model string (e.g., "gpt-4o-mini") or a language model instance.
    */
-  execute(command: string, options?: {
-    timeout?: number;
-  }): Promise<ExecuteResponse>;
+  model: string | BaseChatModel | BaseLanguageModel;
   /**
-   * Download files from the sandbox using LangSmith's native file read API.
-   * @param paths - List of file paths to download
-   * @returns List of FileDownloadResponse objects, one per input path
+   * Backend instance or factory for persisting conversation history.
    */
-  downloadFiles(paths: string[]): Promise<FileDownloadResponse[]>;
+  backend: AnyBackendProtocol | BackendFactory | ((config: {
+    state: unknown;
+    store?: BaseStore;
+  }) => StateBackend);
   /**
-   * Upload files to the sandbox using LangSmith's native file write API.
-   * @param files - List of [path, content] tuples to upload
-   * @returns List of FileUploadResponse objects, one per input file
+   * Threshold(s) that trigger summarization.
+   * Can be a single ContextSize or an array for multiple triggers.
    */
-  uploadFiles(files: Array<[string, Uint8Array]>): Promise<FileUploadResponse[]>;
+  trigger?: ContextSize | ContextSize[];
   /**
-   * Delete this sandbox and mark it as no longer running.
-   *
-   * After calling this, `isRunning` will be `false` and the sandbox
-   * cannot be used again.
+   * Context retention policy after summarization.
+   * Defaults to keeping last 20 messages.
    */
-  close(): Promise<void>;
+  keep?: ContextSize;
   /**
-   * Create and return a new LangSmithSandbox in one step.
-   *
-   * This is the recommended way to create a sandbox — no need to import
-   * anything from `langsmith/experimental/sandbox` directly.
-   *
-   * @example
-   * ```typescript
-   * const sandbox = await LangSmithSandbox.create({ templateName: "deepagents" });
-   * try {
-   *   const agent = createDeepAgent({ model, backend: sandbox });
-   *   await agent.invoke({ messages: [...] });
-   * } finally {
-   *   await sandbox.close();
-   * }
-   * ```
+   * Prompt template for generating summaries.
    */
-  static create(options?: LangSmithSandboxCreateOptions): Promise<LangSmithSandbox>;
+  summaryPrompt?: string;
+  /**
+   * Max tokens to include when generating summary.
+   * Defaults to 4000.
+   */
+  trimTokensToSummarize?: number;
+  /**
+   * Path prefix for storing conversation history.
+   * Defaults to "/conversation_history".
+   */
+  historyPathPrefix?: string;
+  /**
+   * Settings for truncating large tool arguments in old messages.
+   * If not provided, argument truncation is disabled.
+   */
+  truncateArgsSettings?: TruncateArgsSettings;
+}
+/**
+ * Compute summarization defaults based on model profile.
+ * Mirrors Python's `_compute_summarization_defaults`.
+ *
+ * If the model has a profile with `maxInputTokens`, uses fraction-based
+ * settings. Otherwise, uses fixed token/message counts.
+ *
+ * @param resolvedModel - The resolved chat model instance.
+ */
+declare function computeSummarizationDefaults(resolvedModel: BaseChatModel): {
+  trigger: ContextSize;
+  keep: ContextSize;
+  truncateArgsSettings: TruncateArgsSettings;
+};
+/**
+ * Create summarization middleware with backend support for conversation history offloading.
+ *
+ * This middleware:
+ * 1. Monitors conversation length against configured thresholds
+ * 2. When triggered, offloads old messages to backend storage
+ * 3. Generates a summary of offloaded messages
+ * 4. Replaces old messages with the summary, preserving recent context
+ *
+ * @param options - Configuration options
+ * @returns AgentMiddleware for summarization and history offloading
+ */
+declare function createSummarizationMiddleware(options: SummarizationMiddlewareOptions): AgentMiddleware<z$1.ZodObject<{
+  _summarizationSessionId: z$1.ZodOptional<z$1.ZodString>;
+  _summarizationEvent: z$1.ZodOptional<z$1.ZodObject<{
+    cutoffIndex: z$1.ZodNumber;
+    summaryMessage: z$1.ZodCustom<HumanMessage<_messages.MessageStructure<_messages.MessageToolSet>>, HumanMessage<_messages.MessageStructure<_messages.MessageToolSet>>>;
+    filePath: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>>;
+}, z$1.core.$strip>, undefined, unknown, readonly (ClientTool | ServerTool)[]>;
+//#endregion
+//#region src/middleware/async_subagents.d.ts
+/**
+ * Specification for an async subagent running on a remote [Agent Protocol](https://github.com/langchain-ai/agent-protocol)
+ * server.
+ *
+ * Async subagents connect to any Agent Protocol-compliant server via the
+ * LangGraph SDK. They run as background tasks that the main agent can
+ * monitor and update.
+ *
+ * Compatible with LangGraph Platform (managed) and self-hosted servers.
+ * Authentication for LangGraph Platform is handled automatically by the SDK
+ * via environment variables (`LANGGRAPH_API_KEY`, `LANGSMITH_API_KEY`, or
+ * `LANGCHAIN_API_KEY`). For self-hosted servers, pass custom auth via `headers`.
+ */
+interface AsyncSubAgent {
+  /** Unique identifier for the async subagent. */
+  name: string;
+  /** What this subagent does. The main agent uses this to decide when to delegate. */
+  description: string;
+  /** The graph name or assistant ID on the Agent Protocol server. */
+  graphId: string;
+  /** URL of the Agent Protocol server. Defaults to the LangGraph SDK's default endpoint. */
+  url?: string;
+  /** Additional headers to include in requests to the server (e.g. for custom auth). */
+  headers?: Record<string, string>;
+}
+/**
+ * Possible statuses for an async subagent task.
+ *
+ * Statuses set by the middleware tools: `"running"`, `"success"`, `"error"`, `"cancelled"`.
+ * Statuses that may be returned by the remote server: `"pending"`, `"timeout"`, `"interrupted"`.
+ */
+type AsyncTaskStatus = "pending" | "running" | "success" | "error" | "cancelled" | "timeout" | "interrupted";
+/**
+ * A tracked async subagent task persisted in agent state.
+ *
+ * Each task maps to a single thread + run on a remote Agent Protocol server.
+ * The `taskId` is the same as `threadId`, so it can be used to look up
+ * the thread directly via the SDK.
+ */
+interface AsyncTask {
+  /** Unique identifier for the task (same as thread id). */
+  taskId: string;
+  /** Name of the async subagent type that is running. */
+  agentName: string;
+  /** Thread ID on the remote server. */
+  threadId: string;
+  /** Run ID for the current execution on the thread. */
+  runId: string;
+  /** Current task status. */
+  status: AsyncTaskStatus;
+  /** ISO timestamp of when the task was launched. */
+  createdAt: string;
+  /** The prompt/description passed to the subagent when the task was launched. */
+  description?: string;
+  /** ISO timestamp of the most recent task update — set when the task status changes or a follow-up message is sent via the update tool. */
+  updatedAt?: string;
+  /** ISO timestamp of the most recent status poll via the check tool. */
+  checkedAt?: string;
+}
+/**
+ * Options for creating async subagent middleware.
+ */
+interface AsyncSubAgentMiddlewareOptions {
+  /** List of async subagent specifications. Must have at least one. */
+  asyncSubAgents: AsyncSubAgent[];
+  /** System prompt override. Set to `null` to disable. Defaults to {@link ASYNC_TASK_SYSTEM_PROMPT}. */
+  systemPrompt?: string;
 }
+/**
+ * Create middleware that adds async subagent tools to an agent.
+ *
+ * Provides five tools for launching, checking, updating, cancelling, and
+ * listing background tasks on remote Agent Protocol servers. Task state is
+ * persisted in the `asyncTasks` state channel so it survives
+ * context compaction.
+ *
+ * Works with any Agent Protocol-compliant server — LangGraph Platform (managed)
+ * or self-hosted (e.g. a Hono/Express server implementing the Agent Protocol spec).
+ *
+ * @throws {Error} If no async subagents are provided or names are duplicated.
+ *
+ * @example
+ * ```ts
+ * const middleware = createAsyncSubAgentMiddleware({
+ *   asyncSubAgents: [{
+ *     name: "researcher",
+ *     description: "Research agent for deep analysis",
+ *     url: "https://my-agent-protocol-server.example.com",
+ *     graphId: "research_agent",
+ *   }],
+ * });
+ * ```
+ */
+/**
+ * Type guard to distinguish async SubAgents from sync SubAgents/CompiledSubAgents.
+ *
+ * Uses the presence of the `graphId` field as the runtime discriminant —
+ * `AsyncSubAgent` requires it, while `SubAgent` and `CompiledSubAgent` do not have it.
+ */
+declare function isAsyncSubAgent(subAgent: AnySubAgent): subAgent is AsyncSubAgent;
+declare function createAsyncSubAgentMiddleware(options: AsyncSubAgentMiddlewareOptions): _langchain.AgentMiddleware<StateSchema<{
+  asyncTasks: ReducedValue<Record<string, {
+    taskId: string;
+    agentName: string;
+    threadId: string;
+    runId: string;
+    status: string;
+    createdAt: string;
+    description?: string | undefined;
+    updatedAt?: string | undefined;
+    checkedAt?: string | undefined;
+  }> | undefined, Record<string, {
+    taskId: string;
+    agentName: string;
+    threadId: string;
+    runId: string;
+    status: string;
+    createdAt: string;
+    description?: string | undefined;
+    updatedAt?: string | undefined;
+    checkedAt?: string | undefined;
+  }> | undefined>;
+}>, undefined, unknown, (_langchain.DynamicStructuredTool<z.ZodObject<{
+  description: z.ZodString;
+  agentName: z.ZodString;
+}, z.core.$strip>, {
+  description: string;
+  agentName: string;
+}, {
+  description: string;
+  agentName: string;
+}, string | Command<unknown, Record<string, unknown>, string>, unknown, "start_async_task"> | _langchain.DynamicStructuredTool<z.ZodObject<{
+  taskId: z.ZodString;
+}, z.core.$strip>, {
+  taskId: string;
+}, {
+  taskId: string;
+}, string | Command<unknown, Record<string, unknown>, string>, unknown, "check_async_task"> | _langchain.DynamicStructuredTool<z.ZodObject<{
+  taskId: z.ZodString;
+  message: z.ZodString;
+}, z.core.$strip>, {
+  taskId: string;
+  message: string;
+}, {
+  taskId: string;
+  message: string;
+}, string | Command<unknown, Record<string, unknown>, string>, unknown, "update_async_task"> | _langchain.DynamicStructuredTool<z.ZodObject<{
+  taskId: z.ZodString;
+}, z.core.$strip>, {
+  taskId: string;
+}, {
+  taskId: string;
+}, string | Command<unknown, Record<string, unknown>, string>, unknown, "cancel_async_task"> | _langchain.DynamicStructuredTool<z.ZodObject<{
+  statusFilter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, {
+  statusFilter?: string | null | undefined;
+}, {
+  statusFilter?: string | null | undefined;
+}, string | Command<unknown, Record<string, unknown>, string>, unknown, "list_async_tasks">)[]>;
 //#endregion
 //#region src/types.d.ts
 type AnyAnnotationRoot = AnnotationRoot<any>;
+/** Any subagent specification — sync, compiled, or async. */
+type AnySubAgent = SubAgent | CompiledSubAgent | AsyncSubAgent;
 interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {
   _schemaType?: T;
 }
@@ -1921,15 +2441,15 @@ type ExtractSubAgentMiddleware<T> = T extends {
 /**
  * Helper type to flatten and merge middleware from all subagents
  */
-type FlattenSubAgentMiddleware<T extends readonly (SubAgent | CompiledSubAgent)[]> = T extends readonly [] ? readonly [] : T extends readonly [infer First, ...infer Rest] ? Rest extends readonly (SubAgent | CompiledSubAgent)[] ? readonly [...ExtractSubAgentMiddleware<First>, ...FlattenSubAgentMiddleware<Rest>] : ExtractSubAgentMiddleware<First> : readonly [];
+type FlattenSubAgentMiddleware<T extends readonly AnySubAgent[]> = T extends readonly [] ? readonly [] : T extends readonly [infer First, ...infer Rest] ? Rest extends readonly AnySubAgent[] ? readonly [...ExtractSubAgentMiddleware<First>, ...FlattenSubAgentMiddleware<Rest>] : ExtractSubAgentMiddleware<First> : readonly [];
 /**
  * Helper type to merge states from subagent middleware
  */
-type InferSubAgentMiddlewareStates<T extends readonly (SubAgent | CompiledSubAgent)[]> = InferMiddlewareStates<FlattenSubAgentMiddleware<T>>;
+type InferSubAgentMiddlewareStates<T extends readonly AnySubAgent[]> = InferMiddlewareStates<FlattenSubAgentMiddleware<T>>;
 /**
  * Combined state type including custom middleware and subagent middleware states
  */
-type MergedDeepAgentState<TMiddleware extends readonly AgentMiddleware[], TSubagents extends readonly (SubAgent | CompiledSubAgent)[]> = InferMiddlewareStates<TMiddleware> & InferSubAgentMiddlewareStates<TSubagents>;
+type MergedDeepAgentState<TMiddleware extends readonly AgentMiddleware[], TSubagents extends readonly AnySubAgent[]> = InferMiddlewareStates<TMiddleware> & InferSubAgentMiddlewareStates<TSubagents>;
 /**
  * Union of all response format types accepted by `createDeepAgent`.
  *
@@ -1986,7 +2506,7 @@ type InferStructuredResponse<T extends SupportedResponseFormat> = SupportedRespo
  * type Types = InferDeepAgentType<typeof agent, "Subagents">;
  * ```
  */
-interface DeepAgentTypeConfig<TResponse extends Record<string, any> | ResponseFormatUndefined = Record<string, any> | ResponseFormatUndefined, TState extends AnyAnnotationRoot | InteropZodObject | undefined = AnyAnnotationRoot | InteropZodObject | undefined, TContext extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot | InteropZodObject, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], TSubagents extends readonly (SubAgent | CompiledSubAgent)[] = readonly (SubAgent | CompiledSubAgent)[]> extends AgentTypeConfig<TResponse, TState, TContext, TMiddleware, TTools> {
+interface DeepAgentTypeConfig<TResponse extends Record<string, any> | ResponseFormatUndefined = Record<string, any> | ResponseFormatUndefined, TState extends AnyAnnotationRoot | InteropZodObject | undefined = AnyAnnotationRoot | InteropZodObject | undefined, TContext extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot | InteropZodObject, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], TSubagents extends readonly AnySubAgent[] = readonly AnySubAgent[]> extends AgentTypeConfig<TResponse, TState, TContext, TMiddleware, TTools> {
   /** The subagents array type for type-safe streaming */
   Subagents: TSubagents;
 }
@@ -2000,7 +2520,7 @@ interface DefaultDeepAgentTypeConfig extends DeepAgentTypeConfig {
   Context: AnyAnnotationRoot;
   Middleware: readonly AgentMiddleware[];
   Tools: readonly (ClientTool | ServerTool)[];
-  Subagents: readonly (SubAgent | CompiledSubAgent)[];
+  Subagents: readonly AnySubAgent[];
 }
 /**
  * DeepAgent extends ReactAgent with additional subagent type information.
@@ -2101,7 +2621,7 @@ type InferSubagentReactAgentType<TSubagent extends SubAgent | CompiledSubAgent>
  * @typeParam TSubagents - The subagents array type for extracting subagent middleware states
  * @typeParam TTools - The tools array type
  */
-interface CreateDeepAgentParams<TResponse extends SupportedResponseFormat = SupportedResponseFormat, ContextSchema extends AnnotationRoot<any> | InteropZodObject = AnnotationRoot<any>, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], TSubagents extends readonly (SubAgent | CompiledSubAgent)[] = readonly (SubAgent | CompiledSubAgent)[], TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]> {
+interface CreateDeepAgentParams<TResponse extends SupportedResponseFormat = SupportedResponseFormat, ContextSchema extends AnnotationRoot<any> | InteropZodObject = AnnotationRoot<any>, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], TSubagents extends readonly AnySubAgent[] = readonly AnySubAgent[], TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]> {
   /** The model to use (model name string or LanguageModelLike instance). Defaults to claude-sonnet-4-5-20250929 */
   model?: BaseLanguageModel | string;
   /** Tools the agent should have access to */
@@ -2110,7 +2630,13 @@ interface CreateDeepAgentParams<TResponse extends SupportedResponseFormat = Supp
   systemPrompt?: string | SystemMessage;
   /** Custom middleware to apply after standard middleware */
   middleware?: TMiddleware;
-  /** List of subagent specifications for task delegation */
+  /**
+   * List of subagent specifications for task delegation.
+   *
+   * Supports sync SubAgents, CompiledSubAgents, and AsyncSubAgents in the same array.
+   * AsyncSubAgents (identified by their `graphId` field) are automatically separated
+   * at runtime and wired to the async SubAgent middleware.
+   */
   subagents?: TSubagents;
   /** Structured output response format for the agent (Zod schema or other format) */
   responseFormat?: TResponse;
@@ -2125,10 +2651,10 @@ interface CreateDeepAgentParams<TResponse extends SupportedResponseFormat = Supp
    * Can be either a backend instance or a factory function that creates one.
    * The factory receives a config object with state and store.
    */
-  backend?: BackendProtocol | ((config: {
+  backend?: AnyBackendProtocol | ((config: {
     state: unknown;
     store?: BaseStore;
-  }) => BackendProtocol);
+  }) => AnyBackendProtocol);
   /** Optional interrupt configuration mapping tool names to interrupt configs */
   interruptOn?: Record<string, boolean | InterruptOnConfig>;
   /** The name of the agent */
@@ -2175,19 +2701,18 @@ interface CreateDeepAgentParams<TResponse extends SupportedResponseFormat = Supp
 //#endregion
 //#region src/agent.d.ts
 /**
- * Create a Deep Agent with middleware-based architecture.
+ * Create a Deep Agent.
  *
- * Matches Python's create_deep_agent function, using middleware for all features:
- * - Todo management (todoListMiddleware)
- * - Filesystem tools (createFilesystemMiddleware)
- * - Subagent delegation (createSubAgentMiddleware)
- * - Conversation summarization (createSummarizationMiddleware) with backend offloading
- * - Prompt caching (anthropicPromptCachingMiddleware)
- * - Tool call patching (createPatchToolCallsMiddleware)
- * - Human-in-the-loop (humanInTheLoopMiddleware) - optional
+ * This is the main entry point for building a production-style agent with
+ * deepagents. It gives you a strong default runtime (filesystem, tasks,
+ * subagents, summarization) and lets you opt into skills, memory,
+ * human-in-the-loop interrupts, async subagents, and custom middleware.
+ *
+ * The runtime is intentionally opinionated: defaults work out of the box, and
+ * when you customize behavior, the middleware ordering stays deterministic.
  *
  * @param params Configuration parameters for the agent
- * @returns ReactAgent instance ready for invocation with properly inferred state types
+ * @returns Deep Agent instance with inferred state/response types
  *
  * @example
  * ```typescript
@@ -2205,18 +2730,18 @@ interface CreateDeepAgentParams<TResponse extends SupportedResponseFormat = Supp
  * // result.research is properly typed as string
  * ```
  */
-declare function createDeepAgent<TResponse extends SupportedResponseFormat = SupportedResponseFormat, ContextSchema extends InteropZodObject = InteropZodObject, const TMiddleware extends readonly AgentMiddleware[] = readonly [], const TSubagents extends readonly (SubAgent | CompiledSubAgent)[] = readonly [], const TTools extends readonly (ClientTool | ServerTool)[] = readonly []>(params?: CreateDeepAgentParams<TResponse, ContextSchema, TMiddleware, TSubagents, TTools>): DeepAgent<DeepAgentTypeConfig<InferStructuredResponse<TResponse>, undefined, ContextSchema, readonly [AgentMiddleware<zod_v30.ZodObject<{
-  todos: zod_v30.ZodDefault<zod_v30.ZodArray<zod_v30.ZodObject<{
-    content: zod_v30.ZodString;
-    status: zod_v30.ZodEnum<["pending", "in_progress", "completed"]>;
-  }, "strip", zod_v30.ZodTypeAny, {
+declare function createDeepAgent<TResponse extends SupportedResponseFormat = SupportedResponseFormat, ContextSchema extends InteropZodObject = InteropZodObject, const TMiddleware extends readonly AgentMiddleware[] = readonly [], const TSubagents extends readonly AnySubAgent[] = readonly [], const TTools extends readonly (ClientTool | ServerTool)[] = readonly []>(params?: CreateDeepAgentParams<TResponse, ContextSchema, TMiddleware, TSubagents, TTools>): DeepAgent<DeepAgentTypeConfig<InferStructuredResponse<TResponse>, undefined, ContextSchema, readonly [AgentMiddleware<_$zod_v30.ZodObject<{
+  todos: _$zod_v30.ZodDefault<_$zod_v30.ZodArray<_$zod_v30.ZodObject<{
+    content: _$zod_v30.ZodString;
+    status: _$zod_v30.ZodEnum<["pending", "in_progress", "completed"]>;
+  }, "strip", _$zod_v30.ZodTypeAny, {
     content: string;
     status: "completed" | "in_progress" | "pending";
   }, {
     content: string;
     status: "completed" | "in_progress" | "pending";
   }>, "many">>;
-}, "strip", zod_v30.ZodTypeAny, {
+}, "strip", _$zod_v30.ZodTypeAny, {
   todos: {
     content: string;
     status: "completed" | "in_progress" | "pending";
@@ -2226,18 +2751,18 @@ declare function createDeepAgent<TResponse extends SupportedResponseFormat = Sup
     content: string;
     status: "completed" | "in_progress" | "pending";
   }[] | undefined;
-}>, undefined, unknown, readonly [_langchain.DynamicStructuredTool<zod_v30.ZodObject<{
-  todos: zod_v30.ZodArray<zod_v30.ZodObject<{
-    content: zod_v30.ZodString;
-    status: zod_v30.ZodEnum<["pending", "in_progress", "completed"]>;
-  }, "strip", zod_v30.ZodTypeAny, {
+}>, undefined, unknown, readonly [_langchain.DynamicStructuredTool<_$zod_v30.ZodObject<{
+  todos: _$zod_v30.ZodArray<_$zod_v30.ZodObject<{
+    content: _$zod_v30.ZodString;
+    status: _$zod_v30.ZodEnum<["pending", "in_progress", "completed"]>;
+  }, "strip", _$zod_v30.ZodTypeAny, {
     content: string;
     status: "completed" | "in_progress" | "pending";
   }, {
     content: string;
     status: "completed" | "in_progress" | "pending";
   }>, "many">;
-}, "strip", zod_v30.ZodTypeAny, {
+}, "strip", _$zod_v30.ZodTypeAny, {
   todos: {
     content: string;
     status: "completed" | "in_progress" | "pending";
@@ -2265,17 +2790,17 @@ declare function createDeepAgent<TResponse extends SupportedResponseFormat = Sup
   messages: _messages.ToolMessage<_messages.MessageStructure<_messages.MessageToolSet>>[];
 }, string>, unknown, "write_todos">]>, AgentMiddleware<_langgraph.StateSchema<{
   files: _langgraph.ReducedValue<FilesRecord | undefined, FilesRecordUpdate | undefined>;
-}>, undefined, unknown, (_langchain.DynamicStructuredTool<zod.ZodObject<{
-  path: zod.ZodDefault<zod.ZodOptional<zod.ZodString>>;
-}, zod_v4_core0.$strip>, {
+}>, undefined, unknown, (_langchain.DynamicStructuredTool<z$2.ZodObject<{
+  path: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodString>>;
+}, _$zod_v4_core0.$strip>, {
   path: string;
 }, {
   path?: string | undefined;
-}, string, unknown, "ls"> | _langchain.DynamicStructuredTool<zod.ZodObject<{
-  file_path: zod.ZodString;
-  offset: zod.ZodDefault<zod.ZodOptional<zod.ZodCoercedNumber<unknown>>>;
-  limit: zod.ZodDefault<zod.ZodOptional<zod.ZodCoercedNumber<unknown>>>;
-}, zod_v4_core0.$strip>, {
+}, string, unknown, "ls"> | _langchain.DynamicStructuredTool<z$2.ZodObject<{
+  file_path: z$2.ZodString;
+  offset: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodCoercedNumber<unknown>>>;
+  limit: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodCoercedNumber<unknown>>>;
+}, _$zod_v4_core0.$strip>, {
   file_path: string;
   offset: number;
   limit: number;
@@ -2283,10 +2808,17 @@ declare function createDeepAgent<TResponse extends SupportedResponseFormat = Sup
   file_path: string;
   offset?: unknown;
   limit?: unknown;
-}, string, unknown, "read_file"> | _langchain.DynamicStructuredTool<zod.ZodObject<{
-  file_path: zod.ZodString;
-  content: zod.ZodDefault<zod.ZodString>;
-}, zod_v4_core0.$strip>, {
+}, {
+  type: string;
+  text: string;
+}[] | {
+  type: string;
+  mimeType: string;
+  data: string;
+}[], unknown, "read_file"> | _langchain.DynamicStructuredTool<z$2.ZodObject<{
+  file_path: z$2.ZodString;
+  content: z$2.ZodDefault<z$2.ZodString>;
+}, _$zod_v4_core0.$strip>, {
   file_path: string;
   content: string;
 }, {
@@ -2295,12 +2827,12 @@ declare function createDeepAgent<TResponse extends SupportedResponseFormat = Sup
 }, string | _messages.ToolMessage<_messages.MessageStructure<_messages.MessageToolSet>> | _langgraph.Command<unknown, {
   files: Record<string, FileData>;
   messages: _messages.ToolMessage<_messages.MessageStructure<_messages.MessageToolSet>>[];
-}, string>, unknown, "write_file"> | _langchain.DynamicStructuredTool<zod.ZodObject<{
-  file_path: zod.ZodString;
-  old_string: zod.ZodString;
-  new_string: zod.ZodString;
-  replace_all: zod.ZodDefault<zod.ZodOptional<zod.ZodBoolean>>;
-}, zod_v4_core0.$strip>, {
+}, string>, unknown, "write_file"> | _langchain.DynamicStructuredTool<z$2.ZodObject<{
+  file_path: z$2.ZodString;
+  old_string: z$2.ZodString;
+  new_string: z$2.ZodString;
+  replace_all: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodBoolean>>;
+}, _$zod_v4_core0.$strip>, {
   file_path: string;
   old_string: string;
   new_string: string;
@@ -2313,50 +2845,50 @@ declare function createDeepAgent<TResponse extends SupportedResponseFormat = Sup
 }, string | _messages.ToolMessage<_messages.MessageStructure<_messages.MessageToolSet>> | _langgraph.Command<unknown, {
   files: Record<string, FileData>;
   messages: _messages.ToolMessage<_messages.MessageStructure<_messages.MessageToolSet>>[];
-}, string>, unknown, "edit_file"> | _langchain.DynamicStructuredTool<zod.ZodObject<{
-  pattern: zod.ZodString;
-  path: zod.ZodDefault<zod.ZodOptional<zod.ZodString>>;
-}, zod_v4_core0.$strip>, {
+}, string>, unknown, "edit_file"> | _langchain.DynamicStructuredTool<z$2.ZodObject<{
+  pattern: z$2.ZodString;
+  path: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodString>>;
+}, _$zod_v4_core0.$strip>, {
   pattern: string;
   path: string;
 }, {
   pattern: string;
   path?: string | undefined;
-}, string, unknown, "glob"> | _langchain.DynamicStructuredTool<zod.ZodObject<{
-  pattern: zod.ZodString;
-  path: zod.ZodDefault<zod.ZodOptional<zod.ZodString>>;
-  glob: zod.ZodNullable<zod.ZodOptional<zod.ZodString>>;
-}, zod_v4_core0.$strip>, {
+}, string, unknown, "glob"> | _langchain.DynamicStructuredTool<z$2.ZodObject<{
+  pattern: z$2.ZodString;
+  path: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodString>>;
+  glob: z$2.ZodDefault<z$2.ZodNullable<z$2.ZodOptional<z$2.ZodString>>>;
+}, _$zod_v4_core0.$strip>, {
   pattern: string;
   path: string;
-  glob?: string | null | undefined;
+  glob: string | null;
 }, {
   pattern: string;
   path?: string | undefined;
   glob?: string | null | undefined;
-}, string, unknown, "grep"> | _langchain.DynamicStructuredTool<zod.ZodObject<{
-  command: zod.ZodString;
-}, zod_v4_core0.$strip>, {
+}, string, unknown, "grep"> | _langchain.DynamicStructuredTool<z$2.ZodObject<{
+  command: z$2.ZodString;
+}, _$zod_v4_core0.$strip>, {
   command: string;
 }, {
   command: string;
-}, string, unknown, "execute">)[]>, AgentMiddleware<undefined, undefined, unknown, readonly [_langchain.DynamicStructuredTool<zod.ZodObject<{
-  description: zod.ZodString;
-  subagent_type: zod.ZodString;
-}, zod_v4_core0.$strip>, {
+}, string, unknown, "execute">)[]>, AgentMiddleware<undefined, undefined, unknown, readonly [_langchain.DynamicStructuredTool<z$2.ZodObject<{
+  description: z$2.ZodString;
+  subagent_type: z$2.ZodString;
+}, _$zod_v4_core0.$strip>, {
   description: string;
   subagent_type: string;
 }, {
   description: string;
   subagent_type: string;
-}, string | _langgraph.Command<unknown, Record<string, unknown>, string>, unknown, "task">]>, AgentMiddleware<zod.ZodObject<{
-  _summarizationSessionId: zod.ZodOptional<zod.ZodString>;
-  _summarizationEvent: zod.ZodOptional<zod.ZodObject<{
-    cutoffIndex: zod.ZodNumber;
-    summaryMessage: zod.ZodCustom<_messages.HumanMessage<_messages.MessageStructure<_messages.MessageToolSet>>, _messages.HumanMessage<_messages.MessageStructure<_messages.MessageToolSet>>>;
-    filePath: zod.ZodNullable<zod.ZodString>;
-  }, zod_v4_core0.$strip>>;
-}, zod_v4_core0.$strip>, undefined, unknown, readonly (ClientTool | ServerTool)[]>, AgentMiddleware<undefined, undefined, unknown, readonly (ClientTool | ServerTool)[]>, ...TMiddleware, ...FlattenSubAgentMiddleware<TSubagents>], TTools, TSubagents>>;
+}, string | _langgraph.Command<unknown, Record<string, unknown>, string>, unknown, "task">]>, AgentMiddleware<z$2.ZodObject<{
+  _summarizationSessionId: z$2.ZodOptional<z$2.ZodString>;
+  _summarizationEvent: z$2.ZodOptional<z$2.ZodObject<{
+    cutoffIndex: z$2.ZodNumber;
+    summaryMessage: z$2.ZodCustom<_messages.HumanMessage<_messages.MessageStructure<_messages.MessageToolSet>>, _messages.HumanMessage<_messages.MessageStructure<_messages.MessageToolSet>>>;
+    filePath: z$2.ZodNullable<z$2.ZodString>;
+  }, _$zod_v4_core0.$strip>>;
+}, _$zod_v4_core0.$strip>, undefined, unknown, readonly (ClientTool | ServerTool)[]>, AgentMiddleware<undefined, undefined, unknown, readonly (ClientTool | ServerTool)[]>, ...TMiddleware, ...FlattenSubAgentMiddleware<TSubagents>], TTools, TSubagents>>;
 //#endregion
 //#region src/errors.d.ts
 /**
@@ -2549,7 +3081,7 @@ interface AgentMemoryMiddlewareOptions {
  * @deprecated Use `createMemoryMiddleware` from `./memory.js` instead.
  * This function uses direct filesystem access which limits portability.
  */
-declare function createAgentMemoryMiddleware(options: AgentMemoryMiddlewareOptions): AgentMiddleware<any, undefined, unknown, readonly (_langchain_core_tools0.ClientTool | _langchain_core_tools0.ServerTool)[]>;
+declare function createAgentMemoryMiddleware(options: AgentMemoryMiddlewareOptions): AgentMiddleware<any, undefined, unknown, readonly (_$_langchain_core_tools0.ClientTool | _$_langchain_core_tools0.ServerTool)[]>;
 //#endregion
 //#region src/skills/loader.d.ts
 /**
@@ -2603,5 +3135,5 @@ declare function parseSkillMetadata(skillMdPath: string, source: "user" | "proje
  */
 declare function listSkills(options: ListSkillsOptions): SkillMetadata[];
 //#endregion
-export { type AgentMemoryMiddlewareOptions, type BackendFactory, type BackendProtocol, type BackendRuntime, BaseSandbox, type CompiledSubAgent, CompositeBackend, ConfigurationError, type ConfigurationErrorCode, type CreateDeepAgentParams, DEFAULT_GENERAL_PURPOSE_DESCRIPTION, DEFAULT_SUBAGENT_PROMPT, type DeepAgent, type DeepAgentTypeConfig, type DefaultDeepAgentTypeConfig, type EditResult, type ExecuteResponse, type ExtractSubAgentMiddleware, type FileData, type FileDownloadResponse, type FileInfo, type FileOperationError, type FileUploadResponse, FilesystemBackend, type FilesystemMiddlewareOptions, type FlattenSubAgentMiddleware, GENERAL_PURPOSE_SUBAGENT, type GrepMatch, type InferDeepAgentSubagents, type InferDeepAgentType, type InferStructuredResponse, type InferSubAgentMiddlewareStates, type InferSubagentByName, type InferSubagentReactAgentType, LangSmithSandbox, type LangSmithSandboxOptions, type ListSkillsOptions, type SkillMetadata as LoaderSkillMetadata, LocalShellBackend, type LocalShellBackendOptions, MAX_SKILL_DESCRIPTION_LENGTH, MAX_SKILL_FILE_SIZE, MAX_SKILL_NAME_LENGTH, type MaybePromise, type MemoryMiddlewareOptions, type MergedDeepAgentState, type ResolveDeepAgentTypeConfig, type SandboxBackendProtocol, type SandboxDeleteOptions, SandboxError, type SandboxErrorCode, type SandboxGetOrCreateOptions, type SandboxInfo, type SandboxListOptions, type SandboxListResponse, type Settings, type SettingsOptions, type SkillMetadata$1 as SkillMetadata, type SkillsMiddlewareOptions, type StateAndStore, StateBackend, StoreBackend, type StoreBackendOptions, type SubAgent, type SubAgentMiddlewareOptions, type SupportedResponseFormat, TASK_SYSTEM_PROMPT, type WriteResult, computeSummarizationDefaults, createAgentMemoryMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, filesValue, findProjectRoot, isSandboxBackend, listSkills, parseSkillMetadata, resolveBackend };
+export { type AgentMemoryMiddlewareOptions, type AnyBackendProtocol, type AnySubAgent, type AsyncSubAgent, type AsyncSubAgentMiddlewareOptions, type AsyncTask, type AsyncTaskStatus, type BackendFactory, type BackendProtocol, type BackendProtocolV1, type BackendProtocolV2, type BackendRuntime, BaseSandbox, type CompiledSubAgent, type CompletionCallbackOptions, CompositeBackend, ConfigurationError, type ConfigurationErrorCode, type CreateDeepAgentParams, DEFAULT_GENERAL_PURPOSE_DESCRIPTION, DEFAULT_SUBAGENT_PROMPT, type DeepAgent, type DeepAgentTypeConfig, type DefaultDeepAgentTypeConfig, type EditResult, type ExecuteResponse, type ExtractSubAgentMiddleware, type FileData, type FileDownloadResponse, type FileInfo, type FileOperationError, type FileUploadResponse, FilesystemBackend, type FilesystemMiddlewareOptions, type FlattenSubAgentMiddleware, GENERAL_PURPOSE_SUBAGENT, type GlobResult, type GrepMatch, type GrepResult, type InferDeepAgentSubagents, type InferDeepAgentType, type InferStructuredResponse, type InferSubAgentMiddlewareStates, type InferSubagentByName, type InferSubagentReactAgentType, LangSmithSandbox, type LangSmithSandboxOptions, type ListSkillsOptions, type SkillMetadata as LoaderSkillMetadata, LocalShellBackend, type LocalShellBackendOptions, type LsResult, MAX_SKILL_DESCRIPTION_LENGTH, MAX_SKILL_FILE_SIZE, MAX_SKILL_NAME_LENGTH, type MaybePromise, type MemoryMiddlewareOptions, type MergedDeepAgentState, type ReadRawResult, type ReadResult, type ResolveDeepAgentTypeConfig, type SandboxBackendProtocol, type SandboxBackendProtocolV1, type SandboxBackendProtocolV2, type SandboxDeleteOptions, SandboxError, type SandboxErrorCode, type SandboxGetOrCreateOptions, type SandboxInfo, type SandboxListOptions, type SandboxListResponse, type Settings, type SettingsOptions, type SkillMetadata$1 as SkillMetadata, type SkillsMiddlewareOptions, type StateAndStore, StateBackend, StoreBackend, type StoreBackendOptions, type SubAgent, type SubAgentMiddlewareOptions, type SupportedResponseFormat, TASK_SYSTEM_PROMPT, type WriteResult, adaptBackendProtocol, adaptSandboxProtocol, computeSummarizationDefaults, createAgentMemoryMiddleware, createAsyncSubAgentMiddleware, createCompletionCallbackMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, filesValue, findProjectRoot, isAsyncSubAgent, isSandboxBackend, isSandboxProtocol, listSkills, parseSkillMetadata, resolveBackend };
 //# sourceMappingURL=index.d.ts.map