deepagents 1.14.1 → 1.15.0

package/dist/{agent-B05mw_iK.d.cts → agent-FG1QOMBi.d.cts}

@@ -5,6 +5,7 @@ import { AnnotationRoot, AnyStateSchema, Command, ReducedValue, StateDefinitionI
 import { z } from "zod/v4";
 import { BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import * as _messages from "@langchain/core/messages";
+import { BaseMessage } from "@langchain/core/messages";
 import { ClientTool, ServerTool, StructuredTool as StructuredTool$1 } from "@langchain/core/tools";
 import { BaseLanguageModel, LanguageModelLike } from "@langchain/core/language_models/base";
 import { Runnable } from "@langchain/core/runnables";
@@ -907,6 +908,12 @@ interface FilesystemMiddlewareOptions {
    * default. Applies to `ls`, `read_file`, `write_file`, `edit_file`,
    * `glob`, and `grep`.
    *
+   * Paths are canonicalized (`.` and empty segments dropped) before matching.
+   * With `FilesystemBackend` (or a `CompositeBackend` route to one), rules
+   * are also checked against the symlink-resolved target, and a deny on either
+   * form blocks the call — so allow rules must cover a symlink's target, not
+   * just the link.
+   *
    * **Note on `execute`**: permissions are not enforced on `execute` because
    * shell commands can access any path regardless of path-based rules. Using
    * permissions with an execution-capable backend (one where `isSandboxBackend`
@@ -927,6 +934,21 @@ interface FilesystemMiddlewareOptions {
    * argument overrides this default. Set to `null` to disable the cap.
    */
   grepMaxCount?: number | null;
+  /**
+   * Keep binary `read_file` content and inline `HumanMessage` media out of
+   * message history (default: `false`).
+   *
+   * Payloads are written to `/blobs` on the backend and state keeps a
+   * content-addressed reference instead; model requests are rehydrated from
+   * the backend. `HumanMessage` payloads added since the last model response
+   * are replaced starting at the next model call, so the original input
+   * write still lands in checkpoint history for that turn. Useful with
+   * sandbox backends. Has no effect when `/blobs` routes to a `StateBackend`,
+   * since that backend stores files as part of graph state — offloading
+   * there would just relocate the bytes to a different key within the same
+   * checkpoint, not out of it.
+   */
+  offloadBinaryContent?: boolean;
 }
 /**
  * Create middleware that provides built-in filesystem tools and optional custom
@@ -1007,12 +1029,12 @@ declare function createFilesystemMiddleware(options?: FilesystemMiddlewareOption
   offset: number;
   limit: number;
 }, unknown, {
-  type: string;
-  text: string;
-}[] | {
   type: string;
   mimeType: string;
   data: string;
+}[] | {
+  type: string;
+  text: string;
 }[] | ToolMessage<_messages.MessageStructure<_messages.MessageToolSet>>, unknown, "read_file"> | _langchain.DynamicStructuredTool<z.ZodPreprocess<z.ZodObject<{
   file_path: z.ZodString;
   content: z.ZodString;
@@ -1087,7 +1109,7 @@ declare const EXECUTION_SYSTEM_PROMPT: string;
  * Each code represents a distinct misconfiguration that can be detected at
  * agent-construction time. Add new codes here as new validations are added.
  */
-type ConfigurationErrorCode = "TOOL_NAME_COLLISION";
+type ConfigurationErrorCode = "TOOL_NAME_COLLISION" | "SKILL_TOOLS_DUPLICATE_NAME" | "SKILL_TOOLS_UNSUPPORTED_TYPE";
 declare const CONFIGURATION_ERROR_SYMBOL: unique symbol;
 /**
  * Thrown when `createDeepAgent` receives invalid configuration.
@@ -1582,6 +1604,10 @@ interface SubAgent {
    * Note: Custom subagents do NOT inherit skills from the main agent by default.
    * Only the general-purpose subagent inherits the main agent's skills.
    *
+   * Not needed when you pass a `createSkillsMiddleware` in `middleware`, for
+   * example to give the subagent skill `tools`: that middleware takes the
+   * same slot on its own.
+   *
    * @example
    * ```typescript
    * const researcher: SubAgent = {
@@ -1802,8 +1828,12 @@ declare function createPatchToolCallsMiddleware(): AgentMiddleware<undefined, un
  * for the middleware to apply via Command.
  */
 declare class StateBackend implements BackendProtocolV2 {
+  /** Class identity discriminant for {@link StateBackend.isInstance}. */
+  readonly backendKind: "state";
   private runtime;
   private fileFormat;
+  /** Duck-typed so this survives the plain-object copies `adaptBackendProtocol` makes — a class check wouldn't. */
+  static isInstance(backend: unknown): backend is StateBackend;
   constructor(options?: BackendOptions);
   /**
    * @deprecated Pass no `runtime` argument
@@ -2034,10 +2064,49 @@ interface SkillMetadata$1 {
    */
   module?: string;
 }
+/**
+ * Return the skill tools that one `metadata.include_tools` name stands for.
+ *
+ * A resolver lets a skill list tools whose real names are only known at
+ * runtime, such as generated MCP tool names, and lets one name stand for a
+ * family of tools. It's called with the name and the agent's `runtime`, on
+ * every model call while a read or pin of a skill listing that name stays in
+ * context, and again before one of its tools runs. It may return the tools or
+ * a promise of them.
+ *
+ * - Return the same tools for the same name within a thread, or the prompt
+ *   cache breaks: a change moves bytes at a position that has already been
+ *   sent.
+ * - Keep it cheap, or cache, since it runs on every model call.
+ * - One resolver serves every thread, so scope any cache by what the tools
+ *   depend on, usually something in `runtime.context`.
+ * - Names are resolved concurrently, so cache the pending promise, not only
+ *   its result.
+ * - Exceptions propagate out of the model call or tool call. To degrade
+ *   gracefully, catch inside the resolver and return `[]`.
+ *
+ * A name that exactly matches a tool already in the request is claimed by that
+ * tool and never passed to the resolver.
+ *
+ * @example
+ * ```typescript
+ * // e.g. every tool on a Linear MCP connection, whatever their generated names
+ * const resolveSkillTools: SkillToolResolver<{ workspaceId: string }> = async (
+ *   name,
+ *   runtime,
+ * ) => (await toolsForWorkspace(runtime.context.workspaceId))[name] ?? [];
+ *
+ * createSkillsMiddleware({ backend, sources: ["/skills/"], tools: resolveSkillTools });
+ * ```
+ */
+type SkillToolResolver<TContext = unknown> = (name: string, runtime: Runtime<TContext>) => readonly ClientTool[] | Promise<readonly ClientTool[]>;
 /**
  * Options for the skills middleware.
+ *
+ * @typeParam TContext - The agent's context type, as a `tools` resolver
+ *   receives it on `runtime.context`.
  */
-interface SkillsMiddlewareOptions {
+interface SkillsMiddlewareOptions<TContext = unknown> {
   /**
    * Backend instance or factory function for file operations.
    * Use a factory for StateBackend since it requires runtime state.
@@ -2070,6 +2139,18 @@ interface SkillsMiddlewareOptions {
    * ```
    */
   sources: readonly string[];
+  /**
+   * Tools the model sees only after a skill that lists them in its `SKILL.md`
+   * frontmatter, as a space-separated `metadata.include_tools`, is read or
+   * pinned.
+   *
+   * Pass an array of tools, or a {@link SkillToolResolver} that looks up the
+   * tools one `include_tools` name stands for when a skill is read or pinned.
+   * Unlike other middleware's tools, these are never registered with the
+   * agent: see {@link createSkillsMiddleware} for how they are disclosed and
+   * gated.
+   */
+  tools?: readonly ClientTool[] | SkillToolResolver<TContext>;
 }
 /**
  * Zod schema for a single skill metadata entry.
@@ -2124,6 +2205,39 @@ declare const skillsMetadataValue: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<
   allowedTools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
   module: z$1.ZodOptional<z$1.ZodString>;
 }, z$1.core.$strip>>>>;
+/**
+ * State value for a middleware's `pinnedSkills` field: the names of skills to
+ * pin.
+ *
+ * The next time the skills middleware's `beforeModel` runs, before a model
+ * call, each named skill's `SKILL.md`, without its frontmatter, is appended to
+ * the conversation as its own `HumanMessage`, in the order named. The message
+ * is a snapshot: editing the file later doesn't change it, and naming the
+ * skill again appends a new copy.
+ *
+ * Names only, matched exactly against the loaded skills. A name that isn't
+ * loaded, or whose `SKILL.md` can't be read, is skipped without an error. The
+ * key is cleared once consumed, so a later run pins nothing unless it names
+ * skills again. Writes in the same step add up, so parallel tool calls can
+ * each pin skills by returning a `Command`.
+ *
+ * Like {@link skillsMetadataValue}, treat the value as opaque. A middleware
+ * declares it on its state schema to set `pinnedSkills` from its own hooks.
+ *
+ * @example
+ * ```typescript
+ * import { createMiddleware } from "langchain";
+ * import { StateSchema } from "@langchain/langgraph";
+ * import { pinnedSkillsValue } from "deepagents";
+ *
+ * const routeSkills = createMiddleware({
+ *   name: "RouteSkills",
+ *   stateSchema: new StateSchema({ pinnedSkills: pinnedSkillsValue }),
+ *   beforeAgent: (state) => ({ pinnedSkills: skillsFor(state.messages) }),
+ * });
+ * ```
+ */
+declare const pinnedSkillsValue: ReducedValue<string[], string[] | undefined>;
 /**
  * Create backend-agnostic middleware for loading and exposing agent skills.
  *
@@ -2147,8 +2261,62 @@ declare const skillsMetadataValue: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<
  * invalidate from any hook — including mid-run, from `afterModel` — and see
  * the fresh list on the following call. See {@link skillsMetadataValue}.
  *
+ * To guarantee the model gets a skill's instructions, for example when the
+ * user names it, pass its name in `pinnedSkills`. Before the next model call,
+ * each named skill's `SKILL.md`, without its frontmatter, is appended to the
+ * conversation as its own `HumanMessage`, with `additional_kwargs.lc_source`
+ * set to `"pinned_skill"` and the skill's `name`, `path` and `description`
+ * under `additional_kwargs.skill`:
+ *
+ * ```ts
+ * await agent.invoke(
+ *   {
+ *     messages: [new HumanMessage("/write-tests /house-style for auth.py")],
+ *     pinnedSkills: ["write-tests", "house-style"],
+ *   },
+ *   config,
+ * );
+ * ```
+ *
+ * Pins resolve against the skills loaded for the thread, so reset
+ * `skillsMetadata` in the same input to pin a skill added since. See
+ * {@link pinnedSkillsValue}.
+ *
+ * ## Skill tools
+ *
+ * A skill can list the tools its instructions use, separated by spaces, under
+ * `metadata.include_tools` in its `SKILL.md` frontmatter:
+ *
+ * ```yaml
+ * metadata:
+ *   include_tools: create_customer_request list_customer_requests
+ * ```
+ *
+ * Pass those tools as `tools`, either as an array or as a
+ * {@link SkillToolResolver} that looks them up by name when a skill is read
+ * or pinned, so one name can stand for a family of tools whose real names are
+ * only known at runtime. The model sees a skill tool only after it reads, with
+ * `read_file`, a skill that lists it, or the skill is pinned, and only while
+ * that read or pin stays in the conversation it is sent; compaction that drops
+ * the read or pin withdraws the tool.
+ * Until then, calling the tool fails with the standard invalid-tool error and
+ * the tool doesn't run. This controls what is in the model's context; it is
+ * not a security boundary, since the model can read any `SKILL.md` at any
+ * time.
+ *
+ * `include_tools` can also name a tool passed to the agent rather than to this
+ * middleware. That tool wins over a skill tool of the same name. If it is
+ * deferred (`extras: { defer_loading: true }`), reading or pinning the skill
+ * discloses it early, and it stays deferred and searchable; if it is bound,
+ * nothing changes.
+ *
+ *
  * @param options - Configuration options
  * @returns AgentMiddleware for skills loading and injection
+ * @throws {ConfigurationError} If `tools` is neither an array nor a
+ *   function (`SKILL_TOOLS_UNSUPPORTED_TYPE`), an entry isn't a client tool
+ *   (`SKILL_TOOLS_UNSUPPORTED_TYPE`), or two entries share a name
+ *   (`SKILL_TOOLS_DUPLICATE_NAME`).
  *
  * @example
  * ```typescript
@@ -2158,7 +2326,7 @@ declare const skillsMetadataValue: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<
  * });
  * ```
  */
-declare function createSkillsMiddleware(options: SkillsMiddlewareOptions): AgentMiddleware<StateSchema<{
+declare function createSkillsMiddleware<TContext = unknown>(options: SkillsMiddlewareOptions<TContext>): AgentMiddleware<StateSchema<{
   skillsMetadata: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodArray<z$1.ZodObject<{
     name: z$1.ZodString;
     description: z$1.ZodString;
@@ -2169,8 +2337,16 @@ declare function createSkillsMiddleware(options: SkillsMiddlewareOptions): Agent
     allowedTools: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
     module: z$1.ZodOptional<z$1.ZodString>;
   }, z$1.core.$strip>>>>;
-  files: import("@langchain/langgraph").ReducedValue<FilesRecord | undefined, FilesRecordUpdate | undefined>;
-}>, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
+  pinnedSkills: ReducedValue<string[], string[] | undefined>;
+  files: ReducedValue<FilesRecord | undefined, FilesRecordUpdate | undefined>;
+  /**
+   * The skill tools disclosed to the latest model call, each mapped to the
+   * include name that produced it, for the tool-time gate. Written on every
+   * model call of a skills middleware with skill tools. The last write wins,
+   * so a model call retried within one step can write it again.
+   */
+  _skillToolsDisclosed: ReducedValue<Record<string, string> | undefined, Record<string, string> | undefined>;
+}>, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
 /**
  * The middleware value returned by {@link createSkillsMiddleware}.
  *
@@ -2528,6 +2704,40 @@ declare function createAsyncSubAgentMiddleware(options: AsyncSubAgentMiddlewareO
   statusFilter?: string | null | undefined;
 }, string | Command<unknown, Record<string, unknown>, string>, unknown, "list_async_tasks">)[], readonly []>;
 //#endregion
+//#region src/middleware/unsupportedContent.d.ts
+/** Content block types `read_file` may emit that require multimodal model support. */
+declare const MULTIMODAL_BLOCK_TYPES: ReadonlySet<string>;
+type Profile = Record<string, unknown>;
+type Block = Record<string, unknown> & {
+  type: string;
+};
+/**
+ * Whether the model accepts a multimodal block.
+ *
+ * Missing profile fields default to supported, since profile coverage is
+ * incomplete — except `file` blocks, where a missing `fileMimeTypes`
+ * defaults to unsupported (see `fileBlockSupported`).
+ */
+declare function multimodalBlockSupported(block: Block, profile: Profile, inToolMessage: boolean): boolean;
+/**
+ * Without this, a request carrying content the model can't accept (e.g. a
+ * `.zip` file sent to a model without file support) fails with a
+ * non-retryable 400, and since the content stays in history, every later
+ * turn fails the same way. Only the request is changed; messages in state
+ * are left untouched, so switching to a model that accepts the content
+ * sends it again.
+ */
+declare function scrubUnsupportedMultimodalContent(messages: readonly BaseMessage[], model: unknown): BaseMessage[];
+/**
+ * Support is read from `model.profile` (see
+ * https://docs.langchain.com/oss/javascript/langchain/models#model-profiles).
+ *
+ * Place this middleware last in the agent's `middleware` list, so that if
+ * some other middleware changes `request.model`, this one sees the model
+ * that will actually receive the request.
+ */
+declare function createUnsupportedContentMiddleware(): import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
+//#endregion
 //#region src/types.d.ts
 type AnyAnnotationRoot = AnnotationRoot<any>;
 /**
@@ -3493,6 +3703,15 @@ declare class FilesystemBackend implements BackendProtocolV2 {
    * delete(), which may target a symlink itself without following it.
    */
   private assertRealPathWithinRoot;
+  /**
+   * Resolve `key` to the path an operation would actually touch, following
+   * symlinks in every existing segment (including dangling ones). Missing
+   * trailing segments are kept as given.
+   *
+   * Paths inside the root keep the root's configured form. In virtual mode the
+   * result is a virtual path, and a target outside the root throws.
+   */
+  private resolveRealPath;
   /**
    * Resolve the concrete path to unlink for a virtual delete operation.
    */
@@ -3610,7 +3829,7 @@ declare class CompositeBackend implements BackendProtocolV2 {
   constructor(defaultBackend: AnyBackendProtocol, routes: Record<string, AnyBackendProtocol>);
   /** Delegates to default backend's id if it is a sandbox, otherwise empty string. */
   get id(): string;
-  /** Route prefixes registered on this backend (e.g. `["/workspace"]`). */
+  /** Route prefixes registered on this backend, normalized to a trailing slash (e.g. `["/workspace/"]`). */
   get routePrefixes(): string[];
   /**
    * Type guard — returns true if `backend` is a {@link CompositeBackend}.
@@ -3619,6 +3838,16 @@ declare class CompositeBackend implements BackendProtocolV2 {
    * where `instanceof` may fail.
    */
   static isInstance(backend: unknown): backend is CompositeBackend;
+  /**
+   * Returns the backend for `path`, with the matched prefix stripped (`/foo` → `/`).
+   * Routes match on path-segment boundaries: `/foo` matches `/foo/bar` but not `/foobar`.
+   */
+  resolveBackendForPath(path: string): [BackendProtocolV2, string];
+  /**
+   * Resolve symlinks via the backend that owns `path`, re-adding the route
+   * prefix. Returns `path` unchanged when that backend has no realpath hook.
+   */
+  private resolveRealPath;
   /**
    * Determine which backend handles this key and strip prefix.
    *
@@ -4423,12 +4652,12 @@ declare function createDeepAgent<TResponse extends SupportedResponseFormat = Sup
   offset: number;
   limit: number;
 }, unknown, {
-  type: string;
-  text: string;
-}[] | {
   type: string;
   mimeType: string;
   data: string;
+}[] | {
+  type: string;
+  text: string;
 }[] | _messages.ToolMessage<_messages.MessageStructure<_messages.MessageToolSet>>, unknown, "read_file"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
   file_path: import("zod").ZodString;
   content: import("zod").ZodString;
@@ -4476,5 +4705,5 @@ declare function createDeepAgent<TResponse extends SupportedResponseFormat = Sup
   }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>, AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>, ...TMiddleware, ...FlattenSubAgentMiddleware<TSubagents>], TTools, TSubagents, TStreamTransformers>>;
 //#endregion
-export { AsyncTaskStatus as $, PermissionMode as $t, createSettings as A, isSandboxBackend as An, HarnessProfileConfigData as At, FlattenSubAgentMiddleware as B, REQUIRED_MIDDLEWARE_NAMES as Bt, listSkills as C, SandboxGetOrCreateOptions as Cn, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY as Ct, filesValue as D, StateAndStore as Dn, createSubAgentMiddleware as Dt, createAgentMemoryMiddleware as E, SandboxListResponse as En, createSubAgent as Et, CreateDeepAgentParams as F, BackendProtocolV1 as Fn, EMPTY_HARNESS_PROFILE as Ft, InferSubagentByName as G, EXECUTION_SYSTEM_PROMPT as Gt, InferDeepAgentType as H, ConfigurationErrorCode as Ht, DeepAgent as I, SandboxBackendProtocolV1 as In, createHarnessProfile as It, ResolveDeepAgentTypeConfig as J, FilesystemMiddlewareOptions as Jt, InferSubagentReactAgentType as K, SystemPromptConfig as Kt, DeepAgentTypeConfig as L, GeneralPurposeSubagentConfig as Lt, DeepAgentRunStream as M, resolveBackend as Mn, harnessProfileConfigSchema as Mt, SubagentRunStream$1 as N, BackendProtocolV2 as Nn, parseHarnessProfileConfig as Nt, Settings as O, WriteResult as On, getHarnessProfile as Ot, AnySubAgent as P, SandboxBackendProtocolV2 as Pn, serializeProfile as Pt, AsyncTask as Q, FilesystemPermission as Qt, DefaultDeepAgentTypeConfig as R, HarnessProfile as Rt, SkillMetadata as S, SandboxErrorCode as Sn, GENERAL_PURPOSE_SUBAGENT as St, AgentMemoryMiddlewareOptions as T, SandboxListOptions as Tn, SubAgentMiddlewareOptions as Tt, InferStructuredResponse as U, ASYNC_TASK_SYSTEM_PROMPT as Ut, InferDeepAgentSubagents as V, ConfigurationError as Vt, InferSubAgentMiddlewareStates as W, BASE_AGENT_PROMPT as Wt, AsyncSubAgent as X, createFilesystemMiddleware as Xt, SupportedResponseFormat as Y, FsToolName as Yt, AsyncSubAgentMiddlewareOptions as Z, FilesystemOperation as Zt, StoreBackend as _, ReadRawResult as _n, createPatchToolCallsMiddleware as _t, adaptBackendProtocol as a, EditResult as an, createCompletionCallbackMiddleware as at, StoreBackendOptions as b, SandboxDeleteOptions as bn, DEFAULT_SUBAGENT_PROMPT as bt, LangSmithSandbox as c, FileDownloadResponse as cn, MAX_SKILL_NAME_LENGTH as ct, BaseSandbox as d, FileUploadResponse as dn, SkillsMiddlewareOptions as dt, AnyBackendProtocol as en, createAsyncSubAgentMiddleware as et, LocalShellBackend as f, GlobResult as fn, createSkillsMiddleware as ft, FilesystemBackend as g, MaybePromise as gn, StateBackend as gt, CompositeBackend as h, LsResult as hn, createMemoryMiddleware as ht, LangSmithStartSandboxOptions as i, DeleteResult as in, CompletionCallbackOptions as it, findProjectRoot as j, isSandboxProtocol as jn, generalPurposeSubagentConfigSchema as jt, SettingsOptions as k, applyGrepMaxCount as kn, registerHarnessProfile as kt, LangSmithSandboxCreateOptions as l, FileInfo as ln, SkillMetadata$1 as lt, ContextHubBackend as m, GrepResult as mn, MemoryMiddlewareOptions as mt, LangSmithCaptureSnapshotOptions as n, BackendProtocol as nn, computeSummarizationDefaults as nt, adaptSandboxProtocol as o, ExecuteResponse as on, MAX_SKILL_DESCRIPTION_LENGTH as ot, LocalShellBackendOptions as p, GrepMatch as pn, skillsMetadataValue as pt, MergedDeepAgentState as q, TASK_SYSTEM_PROMPT as qt, LangSmithSnapshot as r, BackendRuntime as rn, createSummarizationMiddleware as rt, normalizeReadPagination as s, FileData as sn, MAX_SKILL_FILE_SIZE as st, createDeepAgent as t, BackendFactory as tn, isAsyncSubAgent as tt, LangSmithSandboxOptions as u, FileOperationError as un, SkillMetadataEntry as ut, StoreBackendContext as v, ReadResult as vn, CompiledSubAgent as vt, parseSkillMetadata as w, SandboxInfo as wn, SubAgent as wt, ListSkillsOptions as x, SandboxError as xn, ForkedSubAgent as xt, StoreBackendNamespaceFactory as y, SandboxBackendProtocol as yn, DEFAULT_GENERAL_PURPOSE_DESCRIPTION as yt, ExtractSubAgentMiddleware as z, HarnessProfileOptions as zt };
-//# sourceMappingURL=agent-B05mw_iK.d.cts.map
+export { scrubUnsupportedMultimodalContent as $, TASK_SYSTEM_PROMPT as $t, createSettings as A, SandboxInfo as An, SubAgent as At, FlattenSubAgentMiddleware as B, SandboxBackendProtocolV2 as Bn, serializeProfile as Bt, listSkills as C, ReadRawResult as Cn, createPatchToolCallsMiddleware as Ct, filesValue as D, SandboxError as Dn, ForkedSubAgent as Dt, createAgentMemoryMiddleware as E, SandboxDeleteOptions as En, DEFAULT_SUBAGENT_PROMPT as Et, CreateDeepAgentParams as F, applyGrepMaxCount as Fn, registerHarnessProfile as Ft, InferSubagentByName as G, HarnessProfileOptions as Gt, InferDeepAgentType as H, SandboxBackendProtocolV1 as Hn, createHarnessProfile as Ht, DeepAgent as I, isSandboxBackend as In, HarnessProfileConfigData as It, ResolveDeepAgentTypeConfig as J, ConfigurationErrorCode as Jt, InferSubagentReactAgentType as K, REQUIRED_MIDDLEWARE_NAMES as Kt, DeepAgentTypeConfig as L, isSandboxProtocol as Ln, generalPurposeSubagentConfigSchema as Lt, DeepAgentRunStream as M, SandboxListResponse as Mn, createSubAgent as Mt, SubagentRunStream$1 as N, StateAndStore as Nn, createSubAgentMiddleware as Nt, Settings as O, SandboxErrorCode as On, GENERAL_PURPOSE_SUBAGENT as Ot, AnySubAgent as P, WriteResult as Pn, getHarnessProfile as Pt, multimodalBlockSupported as Q, SystemPromptConfig as Qt, DefaultDeepAgentTypeConfig as R, resolveBackend as Rn, harnessProfileConfigSchema as Rt, SkillMetadata as S, MaybePromise as Sn, StateBackend as St, AgentMemoryMiddlewareOptions as T, SandboxBackendProtocol as Tn, DEFAULT_GENERAL_PURPOSE_DESCRIPTION as Tt, InferStructuredResponse as U, GeneralPurposeSubagentConfig as Ut, InferDeepAgentSubagents as V, BackendProtocolV1 as Vn, EMPTY_HARNESS_PROFILE as Vt, InferSubAgentMiddlewareStates as W, HarnessProfile as Wt, MULTIMODAL_BLOCK_TYPES as X, BASE_AGENT_PROMPT as Xt, SupportedResponseFormat as Y, ASYNC_TASK_SYSTEM_PROMPT as Yt, createUnsupportedContentMiddleware as Z, EXECUTION_SYSTEM_PROMPT as Zt, StoreBackend as _, FileUploadResponse as _n, createSkillsMiddleware as _t, adaptBackendProtocol as a, PermissionMode as an, isAsyncSubAgent as at, StoreBackendOptions as b, GrepResult as bn, MemoryMiddlewareOptions as bt, LangSmithSandbox as c, BackendProtocol as cn, CompletionCallbackOptions as ct, BaseSandbox as d, EditResult as dn, MAX_SKILL_FILE_SIZE as dt, FilesystemMiddlewareOptions as en, AsyncSubAgent as et, LocalShellBackend as f, ExecuteResponse as fn, MAX_SKILL_NAME_LENGTH as ft, FilesystemBackend as g, FileOperationError as gn, SkillsMiddlewareOptions as gt, CompositeBackend as h, FileInfo as hn, SkillToolResolver as ht, LangSmithStartSandboxOptions as i, FilesystemPermission as in, createAsyncSubAgentMiddleware as it, findProjectRoot as j, SandboxListOptions as jn, SubAgentMiddlewareOptions as jt, SettingsOptions as k, SandboxGetOrCreateOptions as kn, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY as kt, LangSmithSandboxCreateOptions as l, BackendRuntime as ln, createCompletionCallbackMiddleware as lt, ContextHubBackend as m, FileDownloadResponse as mn, SkillMetadataEntry as mt, LangSmithCaptureSnapshotOptions as n, createFilesystemMiddleware as nn, AsyncTask as nt, adaptSandboxProtocol as o, AnyBackendProtocol as on, computeSummarizationDefaults as ot, LocalShellBackendOptions as p, FileData as pn, SkillMetadata$1 as pt, MergedDeepAgentState as q, ConfigurationError as qt, LangSmithSnapshot as r, FilesystemOperation as rn, AsyncTaskStatus as rt, normalizeReadPagination as s, BackendFactory as sn, createSummarizationMiddleware as st, createDeepAgent as t, FsToolName as tn, AsyncSubAgentMiddlewareOptions as tt, LangSmithSandboxOptions as u, DeleteResult as un, MAX_SKILL_DESCRIPTION_LENGTH as ut, StoreBackendContext as v, GlobResult as vn, pinnedSkillsValue as vt, parseSkillMetadata as w, ReadResult as wn, CompiledSubAgent as wt, ListSkillsOptions as x, LsResult as xn, createMemoryMiddleware as xt, StoreBackendNamespaceFactory as y, GrepMatch as yn, skillsMetadataValue as yt, ExtractSubAgentMiddleware as z, BackendProtocolV2 as zn, parseHarnessProfileConfig as zt };
+//# sourceMappingURL=agent-FG1QOMBi.d.cts.map