deepagents 1.9.1 → 1.10.1

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import * as _langchain from "langchain";
-import { AgentMiddleware, AgentMiddleware as AgentMiddleware$1, AgentTypeConfig, CreateAgentParams, HumanMessage, InferMiddlewareStates, InterruptOnConfig, ProviderStrategy, ReactAgent, ResponseFormat, ResponseFormatUndefined, Runtime, StructuredTool, SystemMessage, ToolMessage, ToolRuntime, ToolStrategy } from "langchain";
+import { AgentMiddleware, AgentMiddleware as AgentMiddleware$1, AgentRunStream, AgentTypeConfig, CreateAgentParams, HumanMessage, InferMiddlewareStates, InterruptOnConfig, ProviderStrategy, ReactAgent, ResponseFormat, ResponseFormatUndefined, Runtime, StructuredTool, SystemMessage, ToolCallStreamUnion, ToolMessage, ToolRuntime, ToolStrategy } from "langchain";
 import * as _langgraph from "@langchain/langgraph";
-import { AnnotationRoot, Command, ReducedValue, StateSchema } from "@langchain/langgraph";
+import { AnnotationRoot, ChatModelStream, Command, Namespace, NativeStreamTransformer, ReducedValue, StateSchema, StreamTransformer } from "@langchain/langgraph";
 import { z } from "zod/v4";
 import * as _messages from "@langchain/core/messages";
 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 { CaptureSnapshotOptions, CaptureSnapshotOptions as LangSmithCaptureSnapshotOptions, CreateSandboxOptions, Sandbox, Snapshot, Snapshot as LangSmithSnapshot, StartSandboxOptions, StartSandboxOptions as LangSmithStartSandboxOptions } from "langsmith/experimental/sandbox";
 import * as _$zod_v30 from "zod/v3";
 import { BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import * as _$zod_v4_core0 from "zod/v4/core";
@@ -711,6 +711,35 @@ interface FilesystemPermission {
 }
 //#endregion
 //#region src/middleware/fs.d.ts
+/**
+ * Tools that should be excluded from the large result eviction logic.
+ *
+ * This array contains tools that should NOT have their results evicted to the filesystem
+ * when they exceed token limits. Tools are excluded for different reasons:
+ *
+ * 1. Tools with built-in truncation (ls, glob, grep):
+ *    These tools truncate their own output when it becomes too large. When these tools
+ *    produce truncated output due to many matches, it typically indicates the query
+ *    needs refinement rather than full result preservation. In such cases, the truncated
+ *    matches are potentially more like noise and the LLM should be prompted to narrow
+ *    its search criteria instead.
+ *
+ * 2. Tools with problematic truncation behavior (read_file):
+ *    read_file is tricky to handle as the failure mode here is single long lines
+ *    (e.g., imagine a jsonl file with very long payloads on each line). If we try to
+ *    truncate the result of read_file, the agent may then attempt to re-read the
+ *    truncated file using read_file again, which won't help.
+ *
+ * 3. Tools that never exceed limits (edit_file, write_file):
+ *    These tools return minimal confirmation messages and are never expected to produce
+ *    output large enough to exceed token limits, so checking them would be unnecessary.
+ */
+/**
+ * All tool names registered by FilesystemMiddleware.
+ * This is the single source of truth — used by createDeepAgent to detect
+ * collisions with user-supplied tools at construction time.
+ */
+declare const FILESYSTEM_TOOL_NAMES: readonly ["ls", "read_file", "write_file", "edit_file", "glob", "grep", "execute"];
 /**
  * Type for the files state record.
  */
@@ -1676,10 +1705,17 @@ interface LangSmithSandboxOptions {
   defaultTimeout?: number;
 }
 /** Options for the `LangSmithSandbox.create()` static factory. */
-interface LangSmithSandboxCreateOptions extends Omit<CreateSandboxOptions, "name" | "timeout" | "waitForReady"> {
+interface LangSmithSandboxCreateOptions extends Omit<CreateSandboxOptions, "name" | "timeout" | "waitForReady" | "snapshotName"> {
+  /**
+   * Snapshot ID to boot from.
+   * Mutually exclusive with `templateName`.
+   */
+  snapshotId?: string;
   /**
    * Name of the LangSmith sandbox template to use.
-   * @default "deepagents"
+   * Mutually exclusive with `snapshotId`.
+   * @deprecated Use `snapshotId` instead. Template-based creation will be
+   * removed in a future release.
    */
   templateName?: string;
   /**
@@ -1738,6 +1774,33 @@ declare class LangSmithSandbox extends BaseSandbox {
    * cannot be used again.
    */
   close(): Promise<void>;
+  /**
+   * Start a stopped sandbox and wait until it is ready.
+   *
+   * After calling this, `isRunning` will be `true` and the sandbox
+   * can be used for command execution and file operations again.
+   *
+   * @param options - Start options (timeout, signal).
+   */
+  start(options?: StartSandboxOptions): Promise<void>;
+  /**
+   * Stop the sandbox without deleting it.
+   *
+   * Sandbox files are preserved and the sandbox can be restarted later
+   * with `start()`. After calling this, `isRunning` will be `false`.
+   */
+  stop(): Promise<void>;
+  /**
+   * Capture a snapshot from this running sandbox.
+   *
+   * Snapshots can be used to create new sandboxes via
+   * `LangSmithSandbox.create({ snapshotId })`.
+   *
+   * @param name - Name for the snapshot.
+   * @param options - Capture options (checkpoint, timeout).
+   * @returns The created Snapshot in "ready" status.
+   */
+  captureSnapshot(name: string, options?: CaptureSnapshotOptions): Promise<Snapshot>;
   /**
    * Create and return a new LangSmithSandbox in one step.
    *
@@ -1746,7 +1809,10 @@ declare class LangSmithSandbox extends BaseSandbox {
    *
    * @example
    * ```typescript
-   * const sandbox = await LangSmithSandbox.create({ templateName: "deepagents" });
+   * const sandbox = await LangSmithSandbox.create({
+   *   snapshotId: "abc-123",
+   * });
+   *
    * try {
    *   const agent = createDeepAgent({ model, backend: sandbox });
    *   await agent.invoke({ messages: [...] });
@@ -1755,7 +1821,7 @@ declare class LangSmithSandbox extends BaseSandbox {
    * }
    * ```
    */
-  static create(options?: LangSmithSandboxCreateOptions): Promise<LangSmithSandbox>;
+  static create(options: LangSmithSandboxCreateOptions): Promise<LangSmithSandbox>;
 }
 //#endregion
 //#region src/backends/utils.d.ts
@@ -2475,6 +2541,19 @@ interface AsyncTask {
   /** ISO timestamp of the most recent status poll via the check tool. */
   checkedAt?: string;
 }
+/**
+ * Task statuses that will never change.
+ *
+ * When listing tasks, live-status fetches are skipped for tasks whose
+ * cached status is in this set, since they are guaranteed to be final.
+ */
+/**
+ * Names of the tools added by the async subagent middleware.
+ *
+ * Exported so `agent.ts` can include them in `BUILTIN_TOOL_NAMES` and
+ * surface a `ConfigurationError` if a user-provided tool collides.
+ */
+declare const ASYNC_TASK_TOOL_NAMES: readonly ["start_async_task", "check_async_task", "update_async_task", "cancel_async_task", "list_async_tasks"];
 /**
  * Options for creating async subagent middleware.
  */
@@ -2576,8 +2655,100 @@ declare function createAsyncSubAgentMiddleware(options: AsyncSubAgentMiddlewareO
   statusFilter?: string | null | undefined;
 }, string | Command<unknown, Record<string, unknown>, string>, unknown, "list_async_tasks">)[]>;
 //#endregion
+//#region src/stream.d.ts
+/**
+ * Represents a single subagent invocation observed during a deep agent run.
+ *
+ * @typeParam TOutput - The subagent's output state type. Defaults to
+ *   `unknown`; inferred to the subagent's `MergedAgentState` for
+ *   `CompiledSubAgent` via {@link SubagentRunStreamUnion}.
+ */
+interface SubagentRunStream<TOutput = unknown, TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]> {
+  readonly name: string;
+  readonly taskInput: Promise<string>;
+  readonly output: Promise<TOutput>;
+  readonly messages: AsyncIterable<ChatModelStream>;
+  readonly toolCalls: AsyncIterable<ToolCallStreamUnion<TTools>>;
+  readonly subagents: AsyncIterable<SubagentRunStream>;
+}
+/**
+ * Extract the output state type from a subagent spec.
+ * For `CompiledSubAgent<ReactAgent<Types>>`, resolves to the agent's
+ * invoke return type. Falls back to `unknown` for `SubAgent` and
+ * `AsyncSubAgent`.
+ */
+type SubagentOutputOf<T extends AnySubAgent> = T extends CompiledSubAgent<infer R> ? R extends ReactAgent<infer Types> ? Awaited<ReturnType<ReactAgent<Types>["invoke"]>> : unknown : unknown;
+/**
+ * Extract the tools tuple from a subagent spec.
+ * For `CompiledSubAgent<ReactAgent<Types>>`, resolves to `Types["Tools"]`.
+ * Falls back to the default `(ClientTool | ServerTool)[]` for `SubAgent`
+ * and `AsyncSubAgent`.
+ */
+type SubagentToolsOf<T extends AnySubAgent> = T extends CompiledSubAgent<infer R> ? R extends ReactAgent<infer Types> ? Types["Tools"] : readonly (ClientTool | ServerTool)[] : readonly (ClientTool | ServerTool)[];
+/**
+ * A typed `SubagentRunStream` variant for a single subagent spec.
+ * Narrows `.name` to the literal string type, `.output` to the
+ * inferred state type, and `.toolCalls` to the subagent's tools
+ * when available.
+ */
+type NamedSubagentRunStream<T extends AnySubAgent> = T extends {
+  name: infer N extends string;
+} ? SubagentRunStream<SubagentOutputOf<T>, SubagentToolsOf<T>> & {
+  readonly name: N;
+} : SubagentRunStream;
+/**
+ * Discriminated union of {@link SubagentRunStream} variants, one per
+ * subagent in `TSubagents`. Enables TypeScript to narrow `.output`
+ * when the consumer checks `sub.name === "someSubagentName"`.
+ */
+type SubagentRunStreamUnion<TSubagents extends readonly AnySubAgent[]> = { [K in keyof TSubagents]: NamedSubagentRunStream<TSubagents[K]> }[number];
+/**
+ * An {@link AgentRunStream} with native deep-agent projections assigned
+ * directly on the instance by `createGraphRunStream` (via `__native`
+ * transformers).
+ *
+ * This is a pure type overlay — no runtime class exists.  The
+ * `subagents` property is populated at runtime by the
+ * `createSubagentTransformer` registered at compile time.
+ */
+type DeepAgentRunStream<TValues = Record<string, unknown>, TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[], TSubagents extends readonly AnySubAgent[] = readonly AnySubAgent[], TExtensions extends Record<string, unknown> = Record<string, unknown>> = AgentRunStream<TValues, TTools, TExtensions> & {
+  /** Subagent invocation streams from the native SubagentTransformer. */subagents: AsyncIterable<SubagentRunStreamUnion<TSubagents>>;
+};
+interface SubagentProjection {
+  subagents: AsyncIterable<SubagentRunStream>;
+}
+/**
+ * Native transformer that correlates `task` tool calls into
+ * {@link SubagentRunStream} objects and routes child-namespace
+ * `tools` and `messages` events into per-subagent channels.
+ *
+ * Marked `__native: true` — the `subagents` projection key lands
+ * directly on the `GraphRunStream` instance as `run.subagents`.
+ */
+declare function createSubagentTransformer(path: Namespace): () => NativeStreamTransformer<SubagentProjection>;
+//#endregion
 //#region src/types.d.ts
 type AnyAnnotationRoot = AnnotationRoot<any>;
+/**
+ * Literal union of all built-in deep agent tool names.
+ * These are always present on the agent regardless of user-provided tools.
+ */
+type DeepAgentBuiltinToolName = (typeof FILESYSTEM_TOOL_NAMES)[number] | (typeof ASYNC_TASK_TOOL_NAMES)[number] | "task" | "write_todos";
+/**
+ * A placeholder StructuredTool type with a literal `name` for each
+ * built-in tool. Used to thread built-in tool names into the
+ * `ToolCallStreamUnion` so they appear in `run.toolCalls` alongside
+ * user-provided tools.
+ */
+type BuiltinToolPlaceholder<N extends string> = {
+  name: N;
+} & StructuredTool$1;
+/**
+ * Tuple of placeholder tool types for all built-in deep agent tools.
+ * Combined with `TTypes["Tools"]` in the `DeepAgentRunStream` return type.
+ */
+type DeepAgentBuiltinToolsTuple = { [K in DeepAgentBuiltinToolName]: BuiltinToolPlaceholder<K> }[DeepAgentBuiltinToolName][];
+type InferDeepAgentStreamExtensions<T extends ReadonlyArray<() => StreamTransformer<any>>> = T extends readonly [] ? Record<string, never> : T extends readonly [() => StreamTransformer<infer P>, ...infer Rest extends ReadonlyArray<() => StreamTransformer<any>>] ? P & InferDeepAgentStreamExtensions<Rest> : Record<string, unknown>;
 /** Any subagent specification — sync, compiled, or async. */
 type AnySubAgent = SubAgent | CompiledSubAgent | AsyncSubAgent;
 interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {
@@ -2658,7 +2829,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 AnySubAgent[] = readonly AnySubAgent[]> 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[], TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = ReadonlyArray<() => StreamTransformer<any>>> extends AgentTypeConfig<TResponse, TState, TContext, TMiddleware, TTools, TStreamTransformers> {
   /** The subagents array type for type-safe streaming */
   Subagents: TSubagents;
 }
@@ -2673,6 +2844,7 @@ interface DefaultDeepAgentTypeConfig extends DeepAgentTypeConfig {
   Middleware: readonly AgentMiddleware[];
   Tools: readonly (ClientTool | ServerTool)[];
   Subagents: readonly AnySubAgent[];
+  StreamTransformers: readonly [];
 }
 /**
  * DeepAgent extends ReactAgent with additional subagent type information.
@@ -2690,9 +2862,86 @@ interface DefaultDeepAgentTypeConfig extends DeepAgentTypeConfig {
  * type Subagents = InferDeepAgentSubagents<typeof agent>;
  * ```
  */
-type DeepAgent<TTypes extends DeepAgentTypeConfig = DeepAgentTypeConfig> = ReactAgent<TTypes> & {
-  /** Type brand for DeepAgent type inference */readonly "~deepAgentTypes": TTypes;
-};
+interface DeepAgent<TTypes extends DeepAgentTypeConfig = DeepAgentTypeConfig> extends ReactAgent<TTypes> {
+  /** Type brand for DeepAgent type inference */
+  readonly "~deepAgentTypes": TTypes;
+  /**
+   * Executes the agent with the v3 streaming interface, returning an
+   * {@link DeepAgentRunStream} that provides ergonomic, typed projections for
+   * messages, tool calls, subagents, and middleware events.
+   *
+   * Pass `version: "v3"` to opt into this projection-oriented stream. Omitting
+   * `version` preserves the legacy internal LangGraph event-stream behavior
+   * for compatibility with LangGraph Platform integrations.
+   *
+   * This v3 stream is experimental and its API may change in future releases.
+   * It will become the default in a future major release.
+   *
+   * @param state - The initial state for the agent execution. Can be:
+   *   - An object containing `messages` array and any middleware-specific state properties
+   *   - A Command object for more advanced control flow
+   *
+   * @param config - Runtime configuration including:
+   * @param config.version - Must be `"v3"` to use the {@link DeepAgentRunStream}
+   *   interface. The default legacy event stream is maintained for internal
+   *   integrations and should not be used for new user-facing agent streaming.
+   * @param config.context - The context for the agent execution.
+   * @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.
+   * @param config.store - The store for the agent execution for persisting state.
+   * @param config.signal - An optional AbortSignal for the agent execution.
+   * @param config.recursionLimit - The recursion limit for the agent execution.
+   *
+   * @returns A Promise that resolves to an {@link DeepAgentRunStream} providing:
+   *   - `run.messages` — all AI message lifecycles with streaming `.text` and `.reasoning`
+   *   - `run.toolCalls` — individual tool call streams with `.input`, `.output`, `.status`
+   *   - `run.subagents` — subagent delegation streams
+   *   - `run.middleware` — middleware lifecycle events (before/after agent/model)
+   *   - `run.values` — state snapshots (async iterable + promise-like)
+   *   - `run.output` — final agent state when the run completes
+   *   - `run.subgraphs` — child subgraph run streams
+   *   - `run.extensions` — merged projections from user-supplied transformers
+   *
+   * @example
+   * ```typescript
+   * const run = await agent.streamEvents(
+   *   {
+   *     messages: [{ role: "user", content: "What's the weather in Paris?" }],
+   *   },
+   *   { version: "v3" }
+   * );
+   *
+   * // Stream all messages
+   * for await (const msg of run.messages) {
+   *   for await (const token of msg.text) {
+   *     process.stdout.write(token);
+   *   }
+   * }
+   *
+   * // Observe tool calls
+   * for await (const call of run.toolCalls) {
+   *   console.log(`Tool: ${call.name}`, call.input);
+   *   console.log(`Result:`, await call.output);
+   * }
+   *
+   * // Observe subagent delegations
+   * for await (const subagent of run.subagents) {
+   *   console.log(`Subagent: ${subagent.name}`);
+   *
+   *   for await (const msg of subagent.messages) {
+   *     for await (const token of msg.text) {
+   *       process.stdout.write(token);
+   *     }
+   *   }
+   * }
+   *
+   * // Get final state
+   * const state = await run.output;
+   * ```
+   */
+  streamEvents: ((state: Parameters<ReactAgent<TTypes>["invoke"]>[0], config: NonNullable<Parameters<ReactAgent<TTypes>["invoke"]>[1]> & {
+    version: "v3";
+  }) => Promise<DeepAgentRunStream<Awaited<ReturnType<ReactAgent<TTypes>["invoke"]>>, readonly [...TTypes["Tools"], ...DeepAgentBuiltinToolsTuple], TTypes["Subagents"], InferDeepAgentStreamExtensions<TTypes["StreamTransformers"]>>>) & ReactAgent<TTypes>["streamEvents"];
+}
 /**
  * Helper type to resolve a DeepAgentTypeConfig from either:
  * - A DeepAgentTypeConfig directly
@@ -2772,8 +3021,9 @@ type InferSubagentReactAgentType<TSubagent extends SubAgent | CompiledSubAgent>
  * @typeParam TMiddleware - The middleware array type for proper type inference
  * @typeParam TSubagents - The subagents array type for extracting subagent middleware states
  * @typeParam TTools - The tools array type
+ * @typeParam TStreamTransformers - Custom stream transformer factories
  */
-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)[]> {
+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)[], TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []> {
   /** 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 */
@@ -2868,6 +3118,14 @@ interface CreateDeepAgentParams<TResponse extends SupportedResponseFormat = Supp
    * ```
    */
   permissions?: FilesystemPermission[];
+  /**
+   * Optional {@link StreamTransformer} factories to register with the underlying agent.
+   *
+   * Deepagents always registers its built-in subagent transformer; custom
+   * transformers are appended after it and are exposed on `run.extensions`
+   * when using `streamEvents(..., { version: "v3" })`.
+   */
+  streamTransformers?: TStreamTransformers;
 }
 //#endregion
 //#region src/agent.d.ts
@@ -2901,7 +3159,7 @@ 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 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<{
+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 [], const TStreamTransformers extends ReadonlyArray<() => StreamTransformer<any>> = readonly []>(params?: CreateDeepAgentParams<TResponse, ContextSchema, TMiddleware, TSubagents, TTools, TStreamTransformers>): 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"]>;
@@ -3059,7 +3317,7 @@ declare function createDeepAgent<TResponse extends SupportedResponseFormat = Sup
     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>>;
+}, _$zod_v4_core0.$strip>, undefined, unknown, readonly (ClientTool | ServerTool)[]>, AgentMiddleware<undefined, undefined, unknown, readonly (ClientTool | ServerTool)[]>, ...TMiddleware, ...FlattenSubAgentMiddleware<TSubagents>], TTools, TSubagents, TStreamTransformers>>;
 //#endregion
 //#region src/errors.d.ts
 /**
@@ -3306,5 +3564,5 @@ declare function parseSkillMetadata(skillMdPath: string, source: "user" | "proje
  */
 declare function listSkills(options: ListSkillsOptions): SkillMetadata[];
 //#endregion
-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 FilesystemOperation, type FilesystemPermission, 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 PermissionMode, 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 StoreBackendContext, type StoreBackendNamespaceFactory, 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 };
+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 DeepAgentRunStream, type DeepAgentTypeConfig, type DefaultDeepAgentTypeConfig, type EditResult, type ExecuteResponse, type ExtractSubAgentMiddleware, type FileData, type FileDownloadResponse, type FileInfo, type FileOperationError, type FileUploadResponse, FilesystemBackend, type FilesystemMiddlewareOptions, type FilesystemOperation, type FilesystemPermission, type FlattenSubAgentMiddleware, GENERAL_PURPOSE_SUBAGENT, type GlobResult, type GrepMatch, type GrepResult, type InferDeepAgentSubagents, type InferDeepAgentType, type InferStructuredResponse, type InferSubAgentMiddlewareStates, type InferSubagentByName, type InferSubagentReactAgentType, type LangSmithCaptureSnapshotOptions, LangSmithSandbox, type LangSmithSandboxCreateOptions, type LangSmithSandboxOptions, type LangSmithSnapshot, type LangSmithStartSandboxOptions, 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 PermissionMode, 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 StoreBackendContext, type StoreBackendNamespaceFactory, type StoreBackendOptions, type SubAgent, type SubAgentMiddlewareOptions, type SubagentRunStream, type SupportedResponseFormat, TASK_SYSTEM_PROMPT, type WriteResult, adaptBackendProtocol, adaptSandboxProtocol, computeSummarizationDefaults, createAgentMemoryMiddleware, createAsyncSubAgentMiddleware, createCompletionCallbackMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgentMiddleware, createSubagentTransformer, createSummarizationMiddleware, filesValue, findProjectRoot, isAsyncSubAgent, isSandboxBackend, isSandboxProtocol, listSkills, parseSkillMetadata, resolveBackend };
 //# sourceMappingURL=index.d.ts.map