deepagents 1.13.4 → 1.14.0

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as AsyncTaskStatus, $t as BackendFactory, A as createSettings, An as resolveBackend, At as harnessProfileConfigSchema, B as FlattenSubAgentMiddleware, Bt as ConfigurationErrorCode, C as listSkills, Cn as SandboxListOptions, Ct as SubAgentMiddlewareOptions, D as filesValue, Dn as applyGrepMaxCount, Dt as registerHarnessProfile, E as createAgentMemoryMiddleware, En as WriteResult, Et as getHarnessProfile, F as CreateDeepAgentParams, Ft as GeneralPurposeSubagentConfig, G as InferSubagentByName, Gt as TASK_SYSTEM_PROMPT, H as InferDeepAgentType, Ht as BASE_AGENT_PROMPT, I as DeepAgent, It as HarnessProfile, J as ResolveDeepAgentTypeConfig, Jt as createFilesystemMiddleware, K as InferSubagentReactAgentType, Kt as FilesystemMiddlewareOptions, L as DeepAgentTypeConfig, Lt as HarnessProfileOptions, M as DeepAgentRunStream, Mn as SandboxBackendProtocolV2, Mt as serializeProfile, N as SubagentRunStream, Nn as BackendProtocolV1, Nt as EMPTY_HARNESS_PROFILE, O as Settings, On as isSandboxBackend, Ot as HarnessProfileConfigData, P as AnySubAgent, Pn as SandboxBackendProtocolV1, Pt as createHarnessProfile, Q as AsyncTask, Qt as AnyBackendProtocol, R as DefaultDeepAgentTypeConfig, Rt as REQUIRED_MIDDLEWARE_NAMES, S as SkillMetadata, Sn as SandboxInfo, St as SubAgent, T as AgentMemoryMiddlewareOptions, Tn as StateAndStore, Tt as createSubAgentMiddleware, U as InferStructuredResponse, Ut as EXECUTION_SYSTEM_PROMPT, V as InferDeepAgentSubagents, Vt as ASYNC_TASK_SYSTEM_PROMPT, W as InferSubAgentMiddlewareStates, Wt as SystemPromptConfig, X as AsyncSubAgent, Xt as FilesystemPermission, Y as SupportedResponseFormat, Yt as FilesystemOperation, Z as AsyncSubAgentMiddlewareOptions, Zt as PermissionMode, _ as StoreBackend, _n as SandboxBackendProtocol, _t as DEFAULT_GENERAL_PURPOSE_DESCRIPTION, a as adaptBackendProtocol, an as FileData, at as createCompletionCallbackMiddleware, b as StoreBackendOptions, bn as SandboxErrorCode, bt as GENERAL_PURPOSE_SUBAGENT, c as LangSmithSandbox, cn as FileOperationError, ct as MAX_SKILL_NAME_LENGTH, d as BaseSandbox, dn as GrepMatch, dt as createSkillsMiddleware, en as BackendProtocol, et as createAsyncSubAgentMiddleware, f as LocalShellBackend, fn as GrepResult, ft as MemoryMiddlewareOptions, g as FilesystemBackend, gn as ReadResult, gt as CompiledSubAgent, h as CompositeBackend, hn as ReadRawResult, ht as createPatchToolCallsMiddleware, i as LangSmithStartSandboxOptions, in as ExecuteResponse, it as CompletionCallbackOptions, j as findProjectRoot, jn as BackendProtocolV2, jt as parseHarnessProfileConfig, k as SettingsOptions, kn as isSandboxProtocol, kt as generalPurposeSubagentConfigSchema, l as LangSmithSandboxCreateOptions, ln as FileUploadResponse, lt as SkillMetadata$1, m as ContextHubBackend, mn as MaybePromise, mt as StateBackend, n as LangSmithCaptureSnapshotOptions, nn as DeleteResult, nt as computeSummarizationDefaults, o as adaptSandboxProtocol, on as FileDownloadResponse, ot as MAX_SKILL_DESCRIPTION_LENGTH, p as LocalShellBackendOptions, pn as LsResult, pt as createMemoryMiddleware, q as MergedDeepAgentState, qt as FsToolName, r as LangSmithSnapshot, rn as EditResult, rt as createSummarizationMiddleware, s as normalizeReadPagination, sn as FileInfo, st as MAX_SKILL_FILE_SIZE, t as createDeepAgent, tn as BackendRuntime, tt as isAsyncSubAgent, u as LangSmithSandboxOptions, un as GlobResult, ut as SkillsMiddlewareOptions, v as StoreBackendContext, vn as SandboxDeleteOptions, vt as DEFAULT_SUBAGENT_PROMPT, w as parseSkillMetadata, wn as SandboxListResponse, wt as createSubAgent, x as ListSkillsOptions, xn as SandboxGetOrCreateOptions, xt as SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY, y as StoreBackendNamespaceFactory, yn as SandboxError, yt as ForkedSubAgent, z as ExtractSubAgentMiddleware, zt as ConfigurationError } from "./agent-CVBXKZAu.js";
-export { ASYNC_TASK_SYSTEM_PROMPT, type AgentMemoryMiddlewareOptions, type AnyBackendProtocol, type AnySubAgent, type AsyncSubAgent, type AsyncSubAgentMiddlewareOptions, type AsyncTask, type AsyncTaskStatus, BASE_AGENT_PROMPT, type BackendFactory, type BackendProtocol, type BackendProtocolV1, type BackendProtocolV2, type BackendRuntime, BaseSandbox, type CompiledSubAgent, type CompletionCallbackOptions, CompositeBackend, ConfigurationError, type ConfigurationErrorCode, ContextHubBackend, type CreateDeepAgentParams, DEFAULT_GENERAL_PURPOSE_DESCRIPTION, DEFAULT_SUBAGENT_PROMPT, type DeepAgent, type DeepAgentRunStream, type DeepAgentTypeConfig, type DefaultDeepAgentTypeConfig, type DeleteResult, EMPTY_HARNESS_PROFILE, EXECUTION_SYSTEM_PROMPT, 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, type ForkedSubAgent, type FsToolName, GENERAL_PURPOSE_SUBAGENT, type GeneralPurposeSubagentConfig, type GlobResult, type GrepMatch, type GrepResult, type HarnessProfile, type HarnessProfileConfigData, type HarnessProfileOptions, 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, REQUIRED_MIDDLEWARE_NAMES, type ReadRawResult, type ReadResult, type ResolveDeepAgentTypeConfig, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY, 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, type SystemPromptConfig, TASK_SYSTEM_PROMPT, type WriteResult, adaptBackendProtocol, adaptSandboxProtocol, applyGrepMaxCount, computeSummarizationDefaults, createAgentMemoryMiddleware, createAsyncSubAgentMiddleware, createCompletionCallbackMiddleware, createDeepAgent, createFilesystemMiddleware, createHarnessProfile, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgent, createSubAgentMiddleware, createSummarizationMiddleware, filesValue, findProjectRoot, generalPurposeSubagentConfigSchema, getHarnessProfile, harnessProfileConfigSchema, isAsyncSubAgent, isSandboxBackend, isSandboxProtocol, listSkills, normalizeReadPagination, parseHarnessProfileConfig, parseSkillMetadata, registerHarnessProfile, resolveBackend, serializeProfile };
+import { $ as AsyncTaskStatus, $t as PermissionMode, A as createSettings, An as isSandboxBackend, At as HarnessProfileConfigData, B as FlattenSubAgentMiddleware, Bt as REQUIRED_MIDDLEWARE_NAMES, C as listSkills, Cn as SandboxGetOrCreateOptions, Ct as SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY, D as filesValue, Dn as StateAndStore, Dt as createSubAgentMiddleware, E as createAgentMemoryMiddleware, En as SandboxListResponse, Et as createSubAgent, F as CreateDeepAgentParams, Fn as BackendProtocolV1, Ft as EMPTY_HARNESS_PROFILE, G as InferSubagentByName, Gt as EXECUTION_SYSTEM_PROMPT, H as InferDeepAgentType, Ht as ConfigurationErrorCode, I as DeepAgent, In as SandboxBackendProtocolV1, It as createHarnessProfile, J as ResolveDeepAgentTypeConfig, Jt as FilesystemMiddlewareOptions, K as InferSubagentReactAgentType, Kt as SystemPromptConfig, L as DeepAgentTypeConfig, Lt as GeneralPurposeSubagentConfig, M as DeepAgentRunStream, Mn as resolveBackend, Mt as harnessProfileConfigSchema, N as SubagentRunStream, Nn as BackendProtocolV2, Nt as parseHarnessProfileConfig, O as Settings, On as WriteResult, Ot as getHarnessProfile, P as AnySubAgent, Pn as SandboxBackendProtocolV2, Pt as serializeProfile, Q as AsyncTask, Qt as FilesystemPermission, R as DefaultDeepAgentTypeConfig, Rt as HarnessProfile, S as SkillMetadata, Sn as SandboxErrorCode, St as GENERAL_PURPOSE_SUBAGENT, T as AgentMemoryMiddlewareOptions, Tn as SandboxListOptions, Tt as SubAgentMiddlewareOptions, U as InferStructuredResponse, Ut as ASYNC_TASK_SYSTEM_PROMPT, V as InferDeepAgentSubagents, Vt as ConfigurationError, W as InferSubAgentMiddlewareStates, Wt as BASE_AGENT_PROMPT, X as AsyncSubAgent, Xt as createFilesystemMiddleware, Y as SupportedResponseFormat, Yt as FsToolName, Z as AsyncSubAgentMiddlewareOptions, Zt as FilesystemOperation, _ as StoreBackend, _n as ReadRawResult, _t as createPatchToolCallsMiddleware, a as adaptBackendProtocol, an as EditResult, at as createCompletionCallbackMiddleware, b as StoreBackendOptions, bn as SandboxDeleteOptions, bt as DEFAULT_SUBAGENT_PROMPT, c as LangSmithSandbox, cn as FileDownloadResponse, ct as MAX_SKILL_NAME_LENGTH, d as BaseSandbox, dn as FileUploadResponse, dt as SkillsMiddlewareOptions, en as AnyBackendProtocol, et as createAsyncSubAgentMiddleware, f as LocalShellBackend, fn as GlobResult, ft as createSkillsMiddleware, g as FilesystemBackend, gn as MaybePromise, gt as StateBackend, h as CompositeBackend, hn as LsResult, ht as createMemoryMiddleware, i as LangSmithStartSandboxOptions, in as DeleteResult, it as CompletionCallbackOptions, j as findProjectRoot, jn as isSandboxProtocol, jt as generalPurposeSubagentConfigSchema, k as SettingsOptions, kn as applyGrepMaxCount, kt as registerHarnessProfile, l as LangSmithSandboxCreateOptions, ln as FileInfo, lt as SkillMetadata$1, m as ContextHubBackend, mn as GrepResult, mt as MemoryMiddlewareOptions, n as LangSmithCaptureSnapshotOptions, nn as BackendProtocol, nt as computeSummarizationDefaults, o as adaptSandboxProtocol, on as ExecuteResponse, ot as MAX_SKILL_DESCRIPTION_LENGTH, p as LocalShellBackendOptions, pn as GrepMatch, pt as skillsMetadataValue, q as MergedDeepAgentState, qt as TASK_SYSTEM_PROMPT, r as LangSmithSnapshot, rn as BackendRuntime, rt as createSummarizationMiddleware, s as normalizeReadPagination, sn as FileData, st as MAX_SKILL_FILE_SIZE, t as createDeepAgent, tn as BackendFactory, tt as isAsyncSubAgent, u as LangSmithSandboxOptions, un as FileOperationError, ut as SkillMetadataEntry, v as StoreBackendContext, vn as ReadResult, vt as CompiledSubAgent, w as parseSkillMetadata, wn as SandboxInfo, wt as SubAgent, x as ListSkillsOptions, xn as SandboxError, xt as ForkedSubAgent, y as StoreBackendNamespaceFactory, yn as SandboxBackendProtocol, yt as DEFAULT_GENERAL_PURPOSE_DESCRIPTION, z as ExtractSubAgentMiddleware, zt as HarnessProfileOptions } from "./agent-DGkf2K7U.js";
+export { ASYNC_TASK_SYSTEM_PROMPT, type AgentMemoryMiddlewareOptions, type AnyBackendProtocol, type AnySubAgent, type AsyncSubAgent, type AsyncSubAgentMiddlewareOptions, type AsyncTask, type AsyncTaskStatus, BASE_AGENT_PROMPT, type BackendFactory, type BackendProtocol, type BackendProtocolV1, type BackendProtocolV2, type BackendRuntime, BaseSandbox, type CompiledSubAgent, type CompletionCallbackOptions, CompositeBackend, ConfigurationError, type ConfigurationErrorCode, ContextHubBackend, type CreateDeepAgentParams, DEFAULT_GENERAL_PURPOSE_DESCRIPTION, DEFAULT_SUBAGENT_PROMPT, type DeepAgent, type DeepAgentRunStream, type DeepAgentTypeConfig, type DefaultDeepAgentTypeConfig, type DeleteResult, EMPTY_HARNESS_PROFILE, EXECUTION_SYSTEM_PROMPT, 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, type ForkedSubAgent, type FsToolName, GENERAL_PURPOSE_SUBAGENT, type GeneralPurposeSubagentConfig, type GlobResult, type GrepMatch, type GrepResult, type HarnessProfile, type HarnessProfileConfigData, type HarnessProfileOptions, 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, REQUIRED_MIDDLEWARE_NAMES, type ReadRawResult, type ReadResult, type ResolveDeepAgentTypeConfig, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY, 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 SkillMetadataEntry, type SkillsMiddlewareOptions, type StateAndStore, StateBackend, StoreBackend, type StoreBackendContext, type StoreBackendNamespaceFactory, type StoreBackendOptions, type SubAgent, type SubAgentMiddlewareOptions, type SubagentRunStream, type SupportedResponseFormat, type SystemPromptConfig, TASK_SYSTEM_PROMPT, type WriteResult, adaptBackendProtocol, adaptSandboxProtocol, applyGrepMaxCount, computeSummarizationDefaults, createAgentMemoryMiddleware, createAsyncSubAgentMiddleware, createCompletionCallbackMiddleware, createDeepAgent, createFilesystemMiddleware, createHarnessProfile, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgent, createSubAgentMiddleware, createSummarizationMiddleware, filesValue, findProjectRoot, generalPurposeSubagentConfigSchema, getHarnessProfile, harnessProfileConfigSchema, isAsyncSubAgent, isSandboxBackend, isSandboxProtocol, listSkills, normalizeReadPagination, parseHarnessProfileConfig, parseSkillMetadata, registerHarnessProfile, resolveBackend, serializeProfile, skillsMetadataValue };

package/dist/index.js

@@ -1,3 +1,3 @@
-import { A as DEFAULT_GENERAL_PURPOSE_DESCRIPTION, B as StateBackend, C as MAX_SKILL_DESCRIPTION_LENGTH, D as createMemoryMiddleware, E as createSkillsMiddleware, F as createSubAgentMiddleware, G as resolveBackend, H as applyGrepMaxCount, I as computeSummarizationDefaults, K as adaptBackendProtocol, L as createSummarizationMiddleware, M as GENERAL_PURPOSE_SUBAGENT, N as SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY, O as filesValue, P as createSubAgent, R as createFilesystemMiddleware, S as createCompletionCallbackMiddleware, T as MAX_SKILL_NAME_LENGTH, U as isSandboxBackend, V as SandboxError, W as isSandboxProtocol, Z as normalizeReadPagination, _ as createHarnessProfile, a as ASYNC_TASK_SYSTEM_PROMPT, b as createAsyncSubAgentMiddleware, c as TASK_SYSTEM_PROMPT, d as registerHarnessProfile, f as generalPurposeSubagentConfigSchema, g as EMPTY_HARNESS_PROFILE, h as serializeProfile, i as StoreBackend, j as DEFAULT_SUBAGENT_PROMPT, k as createPatchToolCallsMiddleware, l as createDeepAgent, m as parseHarnessProfileConfig, n as BaseSandbox, o as BASE_AGENT_PROMPT, p as harnessProfileConfigSchema, q as adaptSandboxProtocol, r as ContextHubBackend, s as EXECUTION_SYSTEM_PROMPT, t as LangSmithSandbox, u as getHarnessProfile, v as REQUIRED_MIDDLEWARE_NAMES, w as MAX_SKILL_FILE_SIZE, x as isAsyncSubAgent, y as ConfigurationError, z as CompositeBackend } from "./langsmith-BAO_h4J6.js";
-import { a as createAgentMemoryMiddleware, i as parseSkillMetadata, n as FilesystemBackend, o as createSettings, r as listSkills, s as findProjectRoot, t as LocalShellBackend } from "./src-CcY34Ckx.js";
-export { ASYNC_TASK_SYSTEM_PROMPT, BASE_AGENT_PROMPT, BaseSandbox, CompositeBackend, ConfigurationError, ContextHubBackend, DEFAULT_GENERAL_PURPOSE_DESCRIPTION, DEFAULT_SUBAGENT_PROMPT, EMPTY_HARNESS_PROFILE, EXECUTION_SYSTEM_PROMPT, FilesystemBackend, GENERAL_PURPOSE_SUBAGENT, LangSmithSandbox, LocalShellBackend, MAX_SKILL_DESCRIPTION_LENGTH, MAX_SKILL_FILE_SIZE, MAX_SKILL_NAME_LENGTH, REQUIRED_MIDDLEWARE_NAMES, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY, SandboxError, StateBackend, StoreBackend, TASK_SYSTEM_PROMPT, adaptBackendProtocol, adaptSandboxProtocol, applyGrepMaxCount, computeSummarizationDefaults, createAgentMemoryMiddleware, createAsyncSubAgentMiddleware, createCompletionCallbackMiddleware, createDeepAgent, createFilesystemMiddleware, createHarnessProfile, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgent, createSubAgentMiddleware, createSummarizationMiddleware, filesValue, findProjectRoot, generalPurposeSubagentConfigSchema, getHarnessProfile, harnessProfileConfigSchema, isAsyncSubAgent, isSandboxBackend, isSandboxProtocol, listSkills, normalizeReadPagination, parseHarnessProfileConfig, parseSkillMetadata, registerHarnessProfile, resolveBackend, serializeProfile };
+import { A as createPatchToolCallsMiddleware, B as CompositeBackend, C as MAX_SKILL_DESCRIPTION_LENGTH, D as skillsMetadataValue, E as createSkillsMiddleware, F as createSubAgent, G as isSandboxProtocol, H as SandboxError, I as createSubAgentMiddleware, J as adaptSandboxProtocol, K as resolveBackend, L as computeSummarizationDefaults, M as DEFAULT_SUBAGENT_PROMPT, N as GENERAL_PURPOSE_SUBAGENT, O as createMemoryMiddleware, P as SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY, Q as normalizeReadPagination, R as createSummarizationMiddleware, S as createCompletionCallbackMiddleware, T as MAX_SKILL_NAME_LENGTH, U as applyGrepMaxCount, V as StateBackend, W as isSandboxBackend, _ as createHarnessProfile, a as ASYNC_TASK_SYSTEM_PROMPT, b as createAsyncSubAgentMiddleware, c as TASK_SYSTEM_PROMPT, d as registerHarnessProfile, f as generalPurposeSubagentConfigSchema, g as EMPTY_HARNESS_PROFILE, h as serializeProfile, i as StoreBackend, j as DEFAULT_GENERAL_PURPOSE_DESCRIPTION, k as filesValue, l as createDeepAgent, m as parseHarnessProfileConfig, n as BaseSandbox, o as BASE_AGENT_PROMPT, p as harnessProfileConfigSchema, q as adaptBackendProtocol, r as ContextHubBackend, s as EXECUTION_SYSTEM_PROMPT, t as LangSmithSandbox, u as getHarnessProfile, v as REQUIRED_MIDDLEWARE_NAMES, w as MAX_SKILL_FILE_SIZE, x as isAsyncSubAgent, y as ConfigurationError, z as createFilesystemMiddleware } from "./langsmith-3LzYb-m7.js";
+import { a as createAgentMemoryMiddleware, i as parseSkillMetadata, n as FilesystemBackend, o as createSettings, r as listSkills, s as findProjectRoot, t as LocalShellBackend } from "./src-gIoHrhh3.js";
+export { ASYNC_TASK_SYSTEM_PROMPT, BASE_AGENT_PROMPT, BaseSandbox, CompositeBackend, ConfigurationError, ContextHubBackend, DEFAULT_GENERAL_PURPOSE_DESCRIPTION, DEFAULT_SUBAGENT_PROMPT, EMPTY_HARNESS_PROFILE, EXECUTION_SYSTEM_PROMPT, FilesystemBackend, GENERAL_PURPOSE_SUBAGENT, LangSmithSandbox, LocalShellBackend, MAX_SKILL_DESCRIPTION_LENGTH, MAX_SKILL_FILE_SIZE, MAX_SKILL_NAME_LENGTH, REQUIRED_MIDDLEWARE_NAMES, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY, SandboxError, StateBackend, StoreBackend, TASK_SYSTEM_PROMPT, adaptBackendProtocol, adaptSandboxProtocol, applyGrepMaxCount, computeSummarizationDefaults, createAgentMemoryMiddleware, createAsyncSubAgentMiddleware, createCompletionCallbackMiddleware, createDeepAgent, createFilesystemMiddleware, createHarnessProfile, createMemoryMiddleware, createPatchToolCallsMiddleware, createSettings, createSkillsMiddleware, createSubAgent, createSubAgentMiddleware, createSummarizationMiddleware, filesValue, findProjectRoot, generalPurposeSubagentConfigSchema, getHarnessProfile, harnessProfileConfigSchema, isAsyncSubAgent, isSandboxBackend, isSandboxProtocol, listSkills, normalizeReadPagination, parseHarnessProfileConfig, parseSkillMetadata, registerHarnessProfile, resolveBackend, serializeProfile, skillsMetadataValue };

package/dist/{langsmith-BAO_h4J6.js → langsmith-3LzYb-m7.js}

@@ -206,6 +206,21 @@ function formatContentWithLineNumbers(content, startLine = 1) {
 	return formatContentWithLineNumbersAndBoundaries(content, startLine).text;
 }
 /**
+* Join file content into the unmodified source body of a `read_file` result.
+*
+* Source lines are emitted unchanged, with no numbering. A status header
+* carries the line-range metadata separately, so nothing here needs to
+* encode line numbers or escape anything.
+*/
+function formatSourceBlock(content) {
+	let lines;
+	if (typeof content === "string") {
+		lines = content.split("\n");
+		if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
+	} else lines = content;
+	return lines.join("\n");
+}
+/**
 * Check if content is empty and return warning message.
 *
 * @param content - Content to check
@@ -1539,7 +1554,6 @@ var CompositeBackend = class {
 * - Pluggable backends (StateBackend, StoreBackend, FilesystemBackend, CompositeBackend)
 * - Tool result eviction for large outputs
 */
-const INT_FORMATTER = new Intl.NumberFormat("en-US");
 /**
 * Normalizes tool input so that models sending `path` instead of `file_path`
 * still work. If the input has `path` but not `file_path`, copies `path` into
@@ -1609,29 +1623,100 @@ const READ_FILE_TRUNCATION_MSG = `
 
 [Output was truncated due to size limits. The file content is very large. Consider reformatting the file to make it easier to navigate. For example, if this is JSON, use execute(command='jq . {file_path}') to pretty-print it with line breaks. For other formats, you can use appropriate formatting tools to split long lines.]`;
 /**
-* Render backend pagination metadata as guidance for the model.
+* Describe the window a read returned, as status header fields.
 *
 * Backends own source-level pagination because only they know how much of the
-* file was read. The middleware owns presentation: it line-numbers the text
-* and turns optional metadata into a human-readable footer. Keeping the fields
-* optional preserves compatibility with custom backends that predate this
-* contract; those reads simply receive no pagination footer.
+* file was read. The middleware owns presentation: it renders the source
+* unmodified and turns optional metadata into a terse header. Keeping the
+* fields optional preserves compatibility with custom backends that predate
+* this contract — `prepareReadWindow` derives a range for those instead.
 *
-* `nextOffset` is the signal that the read is partial. A result at EOF omits it,
-* so complete reads retain their previous output shape.
+* Returns the `lines A-B[ of T]` field, followed by `next offset N` when the
+* window stopped short of the end of the file.
 */
-function remainingLinesNotice(readResult) {
+function describeReadWindow(readResult) {
 	const { startLine, endLine, nextOffset, totalLines } = readResult;
-	if (startLine === void 0 || endLine === void 0 || nextOffset === void 0 || !Number.isSafeInteger(startLine) || !Number.isSafeInteger(endLine) || !Number.isSafeInteger(nextOffset) || startLine < 1 || endLine < startLine || nextOffset !== endLine || totalLines !== void 0 && (!Number.isSafeInteger(totalLines) || totalLines < endLine)) return "";
-	const readCount = endLine - startLine + 1;
-	const readUnit = readCount === 1 ? "line" : "lines";
-	if (totalLines === void 0) return `\n\n[Read ${readCount} ${readUnit} (lines ${startLine}-${endLine}). More lines remain from offset ${nextOffset}.]`;
-	if (endLine >= totalLines) return "";
-	const remaining = totalLines - endLine;
-	return `\n\n[Read ${readCount} ${readUnit} (lines ${startLine}-${endLine} of ${totalLines} total). ${remaining} ${remaining === 1 ? "line" : "lines"} remaining from offset ${nextOffset}.]`;
+	if (startLine === void 0 || endLine === void 0 || !Number.isSafeInteger(startLine) || !Number.isSafeInteger(endLine) || startLine < 1 || endLine < startLine || totalLines !== void 0 && (!Number.isSafeInteger(totalLines) || totalLines < endLine)) return [];
+	let span = `lines ${startLine}-${endLine}`;
+	if (totalLines !== void 0) span += ` of ${totalLines}`;
+	const fields = [span];
+	if (nextOffset !== void 0 && (totalLines === void 0 || endLine < totalLines)) fields.push(`next offset ${nextOffset}`);
+	return fields;
+}
+/** Render the status header that sits above a text `read_file` result. */
+function readHeader(fields) {
+	return `@@ ${fields.join(" | ")} @@`;
+}
+/** Notice disclosing that a negative `offset` was reinterpreted as the start of the file, or `undefined` for a non-negative offset. */
+function clampedOffsetNotice(offset) {
+	if (offset >= 0) return;
+	return `[Requested offset ${offset} is before the start of the file; read from line 1 instead.]`;
+}
+/**
+* Compose a read result from its notices, status header, and source body.
+*
+* Notices sit above the header, so every line below it is unmodified file
+* content and consumers (including `stripLineNumbers` in the quickjs
+* provider) can tell the two apart by position.
+*/
+function assembleRead(body, options) {
+	const { fields, notices = [] } = options;
+	return [
+		...notices,
+		readHeader(fields),
+		body
+	].join("\n");
+}
+/** Derives a header range from `offset` when the backend left `startLine`/`endLine` unset. */
+function prepareReadWindow(readResult, content, offset) {
+	const body = formatSourceBlock(content);
+	if (readResult.startLine !== void 0 && readResult.endLine !== void 0) return {
+		readResult,
+		body
+	};
+	const startLine = offset + 1;
+	const endLine = startLine + body.split("\n").length - 1;
+	return {
+		readResult: {
+			...readResult,
+			startLine,
+			endLine
+		},
+		body
+	};
+}
+/**
+* Assemble a read cut inside a single source line too long to fit.
+*
+* No offset reaches the remainder of such a line, so the header reports how
+* much of it is shown in place of a resume point.
+*/
+function midlineTruncatedRead(body, readResult, threshold, notices) {
+	const newlineIdx = body.indexOf("\n");
+	const oversized = newlineIdx === -1 ? body.length : newlineIdx;
+	const clipped = {
+		totalLines: readResult.totalLines,
+		startLine: readResult.startLine,
+		endLine: readResult.startLine,
+		nextOffset: void 0
+	};
+	const fieldsFor = (shown) => [
+		...describeReadWindow(clipped),
+		"truncated mid-line",
+		`${shown} of ${oversized} chars`
+	];
+	const reserved = assembleRead("", {
+		fields: fieldsFor(oversized),
+		notices
+	}).length;
+	const shown = Math.max(0, Math.min(oversized, threshold - reserved));
+	return assembleRead(body.slice(0, shown), {
+		fields: fieldsFor(shown),
+		notices
+	});
 }
 /**
-* Fit a line-numbered read into the middleware's output budget without
+* Fit a paginated read into the middleware's output budget without
 * publishing a resume offset that skips content the model did not see.
 *
 * There are two independent forms of limiting:
@@ -1642,38 +1727,50 @@ function remainingLinesNotice(readResult) {
 * If the backend returned lines 1-100 but the middleware only displayed lines
 * 1-30, forwarding the backend's original `nextOffset: 100` would silently skip
 * lines 31-100 on the next read. This function therefore truncates only after a
-* complete source line and rebuilds the remaining-lines notice using the last
-* line actually displayed.
-*
-* Long source lines may occupy several formatted rows (`12`, `12.1`, ...). The
-* formatter records a structured boundary only after the final chunk, so this
-* function does not need to inspect or understand the gutter representation.
-* If no complete source line can fit beside the truncation message, the function
-* falls back to character truncation and omits pagination guidance rather than
-* advertising an unsafe offset.
-*/
-function truncatePaginatedRead(formatted, filePath, readResult, tokenLimit) {
-	const content = formatted.text;
-	const notice = remainingLinesNotice(readResult);
-	if (!tokenLimit || content.length + notice.length < 4 * tokenLimit) return content + notice;
-	const truncationMsg = READ_FILE_TRUNCATION_MSG.replace("{file_path}", filePath);
+* complete source line and rebuilds the header from the last line actually
+* displayed. If no complete source line fits alongside the truncation
+* message, it falls back to `midlineTruncatedRead`, which reports exactly how
+* much of the oversized line is shown rather than guessing at a resume point.
+*/
+function truncatePaginatedRead(body, readResult, options) {
+	const { filePath, tokenLimit, notices = [] } = options;
+	const result = assembleRead(body, {
+		fields: describeReadWindow(readResult),
+		notices
+	});
+	if (!tokenLimit || result.length < 4 * tokenLimit) return result;
+	const truncationMsg = READ_FILE_TRUNCATION_MSG.replace("{file_path}", filePath).trim();
 	const threshold = 4 * tokenLimit;
 	if (readResult.startLine !== void 0 && readResult.endLine !== void 0) {
-		const finalSourceLine = readResult.endLine;
-		const boundaries = formatted.sourceLineBoundaries.filter((boundary) => boundary.sourceLine <= finalSourceLine);
+		const rows = body.split("\n");
+		let position = 0;
+		const boundaries = [];
+		for (let index = 0; index < rows.length; index += 1) {
+			const sourceLine = readResult.startLine + index;
+			if (sourceLine > readResult.endLine) break;
+			position += rows[index].length;
+			boundaries.push({
+				endOffset: position,
+				endLine: sourceLine
+			});
+			position += 1;
+		}
 		for (let index = boundaries.length - 1; index >= 0; index -= 1) {
-			const boundary = boundaries[index];
-			const adjustedNotice = remainingLinesNotice({
+			const { endOffset, endLine } = boundaries[index];
+			const adjustedResult = {
 				totalLines: readResult.totalLines,
 				startLine: readResult.startLine,
-				endLine: boundary.sourceLine,
-				nextOffset: boundary.sourceLine
+				endLine,
+				nextOffset: endLine
+			};
+			const candidate = assembleRead(body.slice(0, endOffset), {
+				fields: [...describeReadWindow(adjustedResult), "truncated due to size"],
+				notices: [...notices, truncationMsg]
 			});
-			if (boundary.endOffset + truncationMsg.length + adjustedNotice.length <= threshold) return content.slice(0, boundary.endOffset) + truncationMsg + adjustedNotice;
+			if (candidate.length <= threshold) return candidate;
 		}
 	}
-	const maxContentLength = Math.max(0, threshold - truncationMsg.length);
-	return content.substring(0, maxContentLength) + truncationMsg;
+	return midlineTruncatedRead(body, readResult, threshold, [...notices, truncationMsg]);
 }
 /**
 * Note appended to grep results that were cut short by the match-count cap.
@@ -2069,8 +2166,7 @@ const READ_FILE_TOOL_DESCRIPTION = context`
 
   Usage:
   - By default, it reads up to ${100} lines starting from the beginning of the file. Use \`offset\`/\`limit\` to page through large files instead of reading them whole.
-  - Results are returned with line numbers starting at \`offset\` + 1 (1 by default), then two spaces, then the source line. Never include these line-number prefixes when editing.
-  - Lines over ${INT_FORMATTER.format(MAX_LINE_LENGTH)} characters are split with continuation markers (e.g. 5.1, 5.2); \`limit\` counts source lines, so continuation rows do not consume the budget.
+  - A status header, \`@@ field | field | ... @@\`, sits above the file content, and every line after it is unmodified file content. When content is truncated, there may be an explanation before the header. Never include the header when editing.
   - Speculatively batch multiple \`read_file\` calls in one response when several files may be useful.
   - An empty file returns a system-reminder warning in place of contents.
   - Large tool results may be offloaded to a file; the tool message gives the path. Read that path here, paging with \`offset\`/\`limit\`.
@@ -2090,7 +2186,7 @@ const EDIT_FILE_TOOL_DESCRIPTION = context`
 
   Usage:
   - You must read the file before editing; this tool errors otherwise.
-  - Preserve the exact indentation from the read output, and never include line-number prefixes in old_string or new_string.
+  - Preserve the exact source indentation from the read output, and never include the read status header in old_string or new_string.
   - Prefer editing an existing file over creating a new one.
   - Only use emojis if the user explicitly requests it.
 `;
@@ -2225,6 +2321,10 @@ function createReadFileTool(backend, options) {
 			}];
 		}
 		let content = typeof readResult.content === "string" ? readResult.content : "";
+		if (content === "System reminder: File exists but has empty contents") return [{
+			type: "text",
+			text: content
+		}];
 		const lines = content.split("\n");
 		let paginationResult = readResult;
 		if (lines.length > limit) {
@@ -2238,9 +2338,15 @@ function createReadFileTool(backend, options) {
 				};
 			}
 		}
+		const { readResult: preparedResult, body } = prepareReadWindow(paginationResult, content, offset);
+		const clampNotice = clampedOffsetNotice(requestedOffset);
 		return [{
 			type: "text",
-			text: truncatePaginatedRead(formatContentWithLineNumbersAndBoundaries(content, paginationResult.startLine ?? offset + 1), file_path, paginationResult, toolTokenLimitBeforeEvict)
+			text: truncatePaginatedRead(body, preparedResult, {
+				filePath: file_path,
+				tokenLimit: toolTokenLimitBeforeEvict,
+				notices: clampNotice ? [clampNotice] : []
+			})
 		}];
 	}, {
 		name: "read_file",
@@ -3490,6 +3596,11 @@ const EXCLUDED_STATE_KEYS = [
 * the parent's private channels (skills metadata, memory contents, etc.)
 * to rebuild an equivalent prompt.
 *
+* A pending invalidation propagates: a fork spawned in the same iteration
+* that set `skillsMetadata` to `null` inherits the `null`, so its mirrored
+* skills middleware reloads from its own sources rather than seeing the
+* parent's last loaded list.
+*
 * Call counts stay excluded: a fork inherits the parent's middleware, so
 * sharing them collides on the parent's channel.
 */
@@ -4454,30 +4565,37 @@ const SkillMetadataEntrySchema = z$1.object({
 	module: z$1.string().optional()
 });
 /**
-* Reducer for skillsMetadata that merges arrays from parallel subagents.
-* Skills are deduplicated by name, with later values overriding earlier ones.
+* State value for a middleware's `skillsMetadata` field.
+*
+* A middleware can only read and write the fields declared on its own state
+* schema. A middleware that needs `skillsMetadata` — to inspect the skills
+* loaded for the thread, or to set the field to `null` and make the next model
+* call reload every source — declares it with this value.
+*
+* Treat the value as opaque: it is meant to be passed to `StateSchema`, and
+* its concrete type is an implementation detail that may change. To type an
+* individual entry, use {@link SkillMetadataEntry}.
+*
+* @example
+* ```typescript
+* import { createMiddleware } from "langchain";
+* import { StateSchema } from "@langchain/langgraph";
+* import { skillsMetadataValue } from "deepagents";
 *
-* @param current - The current skillsMetadata array (from state)
-* @param update - The new skillsMetadata array (from a subagent update)
-* @returns Merged array with duplicates resolved by name (later values win)
+* const reloadEditedSkills = createMiddleware({
+*   name: "ReloadEditedSkills",
+*   stateSchema: new StateSchema({ skillsMetadata: skillsMetadataValue }),
+*   afterAgent: (state) =>
+*     agentEditedSkills(state) ? { skillsMetadata: null } : undefined,
+* });
+* ```
 */
-function skillsMetadataReducer(current, update) {
-	if (!update || update.length === 0) return current || [];
-	if (!current || current.length === 0) return update;
-	const merged = /* @__PURE__ */ new Map();
-	for (const skill of current) merged.set(skill.name, skill);
-	for (const skill of update) merged.set(skill.name, skill);
-	return Array.from(merged.values());
-}
+const skillsMetadataValue = z$1.array(SkillMetadataEntrySchema).nullish();
 /**
 * State schema for skills middleware.
-* Uses ReducedValue for skillsMetadata to allow concurrent updates from parallel subagents.
 */
 const SkillsStateSchema = new StateSchema({
-	skillsMetadata: new ReducedValue(z$1.array(SkillMetadataEntrySchema).default(() => []), {
-		inputSchema: z$1.array(SkillMetadataEntrySchema).optional(),
-		reducer: skillsMetadataReducer
-	}),
+	skillsMetadata: skillsMetadataValue,
 	files: filesValue
 });
 /**
@@ -4814,6 +4932,21 @@ function validateModulePath(raw) {
 * pattern: skill names and descriptions are shown in the prompt, but the agent
 * reads full SKILL.md content only when needed.
 *
+* Skills are loaded once per thread and stored in state. To pick up skills
+* added, edited, or deleted since then, set `skillsMetadata` to `null`; the
+* next model call reloads every source:
+*
+* ```ts
+* await agent.updateState(config, { skillsMetadata: null });
+* // or as part of the next run's input
+* await agent.invoke({ messages, skillsMetadata: null }, config);
+* ```
+*
+* Loading happens in `beforeModel`, so the reload is served by the next model
+* call rather than the next run. A middleware of your own can therefore
+* invalidate from any hook — including mid-run, from `afterModel` — and see
+* the fresh list on the following call. See {@link skillsMetadataValue}.
+*
 * @param options - Configuration options
 * @returns AgentMiddleware for skills loading and injection
 *
@@ -4827,17 +4960,11 @@ function validateModulePath(raw) {
 */
 function createSkillsMiddleware(options) {
 	const { backend, sources } = options;
-	let loadedSkills = [];
 	return createMiddleware({
 		name: "SkillsMiddleware",
 		stateSchema: SkillsStateSchema,
-		async beforeAgent(state) {
-			const stateHasSkills = "skillsMetadata" in state && Array.isArray(state.skillsMetadata) && state.skillsMetadata.length > 0;
-			if (loadedSkills.length > 0) return stateHasSkills ? void 0 : { skillsMetadata: loadedSkills };
-			if (stateHasSkills) {
-				loadedSkills = state.skillsMetadata;
-				return;
-			}
+		async beforeModel(state) {
+			if (state.skillsMetadata !== null && state.skillsMetadata !== void 0) return;
 			const resolvedBackend = await resolveBackend(backend, { state });
 			const allSkills = /* @__PURE__ */ new Map();
 			for (const sourcePath of sources) try {
@@ -4846,11 +4973,10 @@ function createSkillsMiddleware(options) {
 			} catch (error) {
 				console.debug(`[BackendSkillsMiddleware] Failed to load skills from ${sourcePath}:`, error);
 			}
-			loadedSkills = Array.from(allSkills.values());
-			return { skillsMetadata: loadedSkills };
+			return { skillsMetadata: Array.from(allSkills.values()) };
 		},
 		wrapModelCall(request, handler) {
-			const skillsMetadata = loadedSkills.length > 0 ? loadedSkills : request.state?.skillsMetadata || [];
+			const skillsMetadata = request.state?.skillsMetadata || [];
 			const skillsLocations = formatSkillsLocations(sources);
 			const skillsList = formatSkillsList(skillsMetadata, sources);
 			const skillsSection = SKILLS_SYSTEM_PROMPT.replace("{skills_locations}", skillsLocations).replace("{skills_list}", skillsList);
@@ -8752,6 +8878,6 @@ var LangSmithSandbox = class LangSmithSandbox extends BaseSandbox {
 	}
 };
 //#endregion
-export { DEFAULT_GENERAL_PURPOSE_DESCRIPTION as A, StateBackend as B, MAX_SKILL_DESCRIPTION_LENGTH as C, createMemoryMiddleware as D, createSkillsMiddleware as E, createSubAgentMiddleware as F, resolveBackend as G, applyGrepMaxCount as H, computeSummarizationDefaults as I, checkEmptyContent as J, adaptBackendProtocol as K, createSummarizationMiddleware as L, GENERAL_PURPOSE_SUBAGENT as M, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY as N, filesValue as O, createSubAgent as P, performStringReplacement as Q, createFilesystemMiddleware as R, createCompletionCallbackMiddleware as S, MAX_SKILL_NAME_LENGTH as T, isSandboxBackend as U, SandboxError as V, isSandboxProtocol as W, isTextMimeType as X, getMimeType as Y, normalizeReadPagination as Z, createHarnessProfile as _, ASYNC_TASK_SYSTEM_PROMPT as a, createAsyncSubAgentMiddleware as b, TASK_SYSTEM_PROMPT as c, registerHarnessProfile as d, generalPurposeSubagentConfigSchema as f, EMPTY_HARNESS_PROFILE as g, serializeProfile as h, StoreBackend as i, DEFAULT_SUBAGENT_PROMPT as j, createPatchToolCallsMiddleware as k, createDeepAgent as l, parseHarnessProfileConfig as m, BaseSandbox as n, BASE_AGENT_PROMPT as o, harnessProfileConfigSchema as p, adaptSandboxProtocol as q, ContextHubBackend as r, EXECUTION_SYSTEM_PROMPT as s, LangSmithSandbox as t, getHarnessProfile as u, REQUIRED_MIDDLEWARE_NAMES as v, MAX_SKILL_FILE_SIZE as w, isAsyncSubAgent as x, ConfigurationError as y, CompositeBackend as z };
+export { performStringReplacement as $, createPatchToolCallsMiddleware as A, CompositeBackend as B, MAX_SKILL_DESCRIPTION_LENGTH as C, skillsMetadataValue as D, createSkillsMiddleware as E, createSubAgent as F, isSandboxProtocol as G, SandboxError as H, createSubAgentMiddleware as I, adaptSandboxProtocol as J, resolveBackend as K, computeSummarizationDefaults as L, DEFAULT_SUBAGENT_PROMPT as M, GENERAL_PURPOSE_SUBAGENT as N, createMemoryMiddleware as O, SUBAGENT_RESPONSE_FORMAT_CONFIG_KEY as P, normalizeReadPagination as Q, createSummarizationMiddleware as R, createCompletionCallbackMiddleware as S, MAX_SKILL_NAME_LENGTH as T, applyGrepMaxCount as U, StateBackend as V, isSandboxBackend as W, getMimeType as X, checkEmptyContent as Y, isTextMimeType as Z, createHarnessProfile as _, ASYNC_TASK_SYSTEM_PROMPT as a, createAsyncSubAgentMiddleware as b, TASK_SYSTEM_PROMPT as c, registerHarnessProfile as d, generalPurposeSubagentConfigSchema as f, EMPTY_HARNESS_PROFILE as g, serializeProfile as h, StoreBackend as i, DEFAULT_GENERAL_PURPOSE_DESCRIPTION as j, filesValue as k, createDeepAgent as l, parseHarnessProfileConfig as m, BaseSandbox as n, BASE_AGENT_PROMPT as o, harnessProfileConfigSchema as p, adaptBackendProtocol as q, ContextHubBackend as r, EXECUTION_SYSTEM_PROMPT as s, LangSmithSandbox as t, getHarnessProfile as u, REQUIRED_MIDDLEWARE_NAMES as v, MAX_SKILL_FILE_SIZE as w, isAsyncSubAgent as x, ConfigurationError as y, createFilesystemMiddleware as z };
 
-//# sourceMappingURL=langsmith-BAO_h4J6.js.map
+//# sourceMappingURL=langsmith-3LzYb-m7.js.map