@botbotgo/agent-harness 0.0.227 → 0.0.229

package/dist/contracts/workspace.d.ts

@@ -15,10 +15,18 @@ export type ParsedAgentObject = {
     memorySources: string[];
     subagentRefs: string[];
     subagentPathRefs: string[];
+    asyncSubagents?: ParsedAsyncSubAgent[];
     langchainAgentConfig?: Record<string, unknown>;
     deepAgentConfig?: Record<string, unknown>;
     sourcePath: string;
 };
+export type ParsedAsyncSubAgent = {
+    name: string;
+    description: string;
+    graphId: string;
+    url?: string;
+    headers?: Record<string, string>;
+};
 export type ParsedAgentToolBinding = {
     ref: string;
     overrides?: Record<string, unknown>;
@@ -172,6 +180,14 @@ export type CompiledSubAgent = {
     responseFormat?: unknown;
     middleware?: Array<Record<string, unknown>>;
 };
+export type CompiledAsyncSubAgent = {
+    name: string;
+    description: string;
+    graphId: string;
+    url?: string;
+    headers?: Record<string, string>;
+};
+export type CompiledDeepAgentSubAgent = CompiledSubAgent | CompiledAsyncSubAgent;
 export type LangChainAgentParams = {
     model: CompiledModel;
     tools: CompiledTool[];
@@ -192,7 +208,7 @@ export type DeepAgentParams = {
     responseFormat?: unknown;
     contextSchema?: unknown;
     middleware?: Array<Record<string, unknown>>;
-    subagents: CompiledSubAgent[];
+    subagents: CompiledDeepAgentSubAgent[];
     interruptOn?: Record<string, boolean | object>;
     backend?: Record<string, unknown>;
     store?: Record<string, unknown>;

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.226";
+export declare const AGENT_HARNESS_VERSION = "0.0.228";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.226";
+export const AGENT_HARNESS_VERSION = "0.0.228";

package/dist/resource/resource-impl.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { stat } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { CompositeBackend, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
+import { CompositeBackend, LangSmithSandbox, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
 import { getBindingBackendConfig, getBindingExecutionView, getBindingPrimaryModel } from "../runtime/support/compiled-binding.js";
 import { resolveCompiledEmbeddingModelRef } from "../runtime/support/embedding-models.js";
 import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
@@ -133,7 +133,60 @@ class CompatibleCompositeBackend {
         return this.composite.downloadFiles(paths);
     }
 }
-const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.';
+function omitKind(config) {
+    const { kind: _kind, ...rest } = config ?? {};
+    return rest;
+}
+class LazyLangSmithSandbox {
+    config;
+    sandboxPromise = null;
+    constructor(config) {
+        this.config = config;
+    }
+    get id() {
+        return "langsmith-pending";
+    }
+    get isRunning() {
+        return this.sandboxPromise !== null;
+    }
+    getSandbox() {
+        if (!this.sandboxPromise) {
+            this.sandboxPromise = LangSmithSandbox.create(omitKind(this.config));
+        }
+        return this.sandboxPromise;
+    }
+    async read(filePath, offset, limit) {
+        return (await this.getSandbox()).read(filePath, offset, limit);
+    }
+    async edit(filePath, oldString, newString, replaceAll) {
+        return (await this.getSandbox()).edit(filePath, oldString, newString, replaceAll);
+    }
+    async ls(dirPath) {
+        return (await this.getSandbox()).ls(dirPath);
+    }
+    async glob(pattern, searchPath) {
+        return (await this.getSandbox()).glob(pattern, searchPath);
+    }
+    async write(filePath, content) {
+        return (await this.getSandbox()).write(filePath, content);
+    }
+    async execute(command) {
+        return (await this.getSandbox()).execute(command);
+    }
+    async uploadFiles(files) {
+        return (await this.getSandbox()).uploadFiles(files);
+    }
+    async downloadFiles(paths) {
+        return (await this.getSandbox()).downloadFiles(paths);
+    }
+    async close() {
+        if (!this.sandboxPromise) {
+            return;
+        }
+        await (await this.sandboxPromise).close();
+    }
+}
+const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend, LangSmithSandbox.';
 function unsupportedInlineBackend(kind) {
     throw new Error(INLINE_BACKEND_ERROR.replace("%s", kind));
 }
@@ -172,6 +225,8 @@ function createInlineBackendInstance(workspaceRoot, kind, config, runtimeLike) {
             return new StateBackend(runtimeLike);
         case "StoreBackend":
             return new StoreBackend(runtimeLike);
+        case "LangSmithSandbox":
+            return new LazyLangSmithSandbox(config);
         default:
             return unsupportedInlineBackend(kind);
     }
@@ -193,6 +248,8 @@ function createInlineBackendResolver(workspace) {
                     return createInlineBackendInstance(workspace.workspaceRoot, "StateBackend", backendConfig, runtimeLike);
                 case "StoreBackend":
                     return createInlineBackendInstance(workspace.workspaceRoot, "StoreBackend", backendConfig, runtimeLike);
+                case "LangSmithSandbox":
+                    return createInlineBackendInstance(workspace.workspaceRoot, "LangSmithSandbox", backendConfig, runtimeLike);
                 case "CompositeBackend": {
                     const stateConfig = typeof backendConfig.state === "object" && backendConfig.state
                         ? backendConfig.state

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -8,7 +8,28 @@ export type BuiltinMiddlewareBackend = {
         is_dir?: boolean;
         size?: number;
     }>;
-    read?: (filePath: string, offset?: number, limit?: number) => Promise<string> | string;
+    ls?: (path: string) => Promise<{
+        files?: Array<{
+            path: string;
+            isDir?: boolean;
+            size?: number;
+        }>;
+        error?: string;
+    }> | {
+        files?: Array<{
+            path: string;
+            isDir?: boolean;
+            size?: number;
+        }>;
+        error?: string;
+    };
+    read?: (filePath: string, offset?: number, limit?: number) => Promise<string | {
+        content?: string | Uint8Array;
+        error?: string;
+    }> | string | {
+        content?: string | Uint8Array;
+        error?: string;
+    };
     write?: (filePath: string, content: string) => Promise<{
         error?: string;
         path?: string;
@@ -34,6 +55,17 @@ export type BuiltinMiddlewareBackend = {
     }>> | Array<{
         path: string;
     }>;
+    glob?: (pattern: string, path?: string) => Promise<{
+        files?: Array<{
+            path: string;
+        }>;
+        error?: string;
+    }> | {
+        files?: Array<{
+            path: string;
+        }>;
+        error?: string;
+    };
     grepRaw?: (pattern: string, path?: string | null, glob?: string | null) => Promise<Array<{
         path: string;
         line: number;
@@ -43,6 +75,27 @@ export type BuiltinMiddlewareBackend = {
         line: number;
         text: string;
     }> | string;
+    grep?: (pattern: string, path?: string | null, glob?: string | null) => Promise<{
+        matches?: Array<{
+            path: string;
+            lineNumber?: number;
+            line_number?: number;
+            content?: string;
+            line?: number;
+            text?: string;
+        }>;
+        error?: string;
+    }> | {
+        matches?: Array<{
+            path: string;
+            lineNumber?: number;
+            line_number?: number;
+            content?: string;
+            line?: number;
+            text?: string;
+        }>;
+        error?: string;
+    };
     execute?: (command: string) => Promise<{
         output: string;
         exitCode: number | null;

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -2,6 +2,15 @@ import { z } from "zod";
 import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
 import { summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
+function toDisplayContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (content instanceof Uint8Array) {
+        return new TextDecoder().decode(content);
+    }
+    return "";
+}
 export async function createBuiltinMiddlewareTools(backend, options) {
     const tools = new Map();
     tools.set("write_todos", {
@@ -25,7 +34,14 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
         invoke: async (input) => {
             const targetPath = isRecord(input) && typeof input.path === "string" ? input.path : "/";
-            const infos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
+            const legacyInfos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
+            const infos = legacyInfos.length > 0
+                ? legacyInfos
+                : ((await Promise.resolve(backend.ls?.(targetPath)))?.files ?? []).map((info) => ({
+                    path: info.path,
+                    is_dir: info.isDir,
+                    size: info.size,
+                }));
             if (infos.length === 0) {
                 return `No files found in ${targetPath}`;
             }
@@ -44,7 +60,11 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             const filePath = typeof typed.file_path === "string" ? typed.file_path : "";
             const offset = typeof typed.offset === "number" ? typed.offset : 0;
             const limit = typeof typed.limit === "number" ? typed.limit : 500;
-            return Promise.resolve(backend.read?.(filePath, offset, limit)) ?? "";
+            const result = await Promise.resolve(backend.read?.(filePath, offset, limit));
+            if (typeof result === "string") {
+                return result;
+            }
+            return toDisplayContent(result?.content);
         },
     });
     tools.set("write_file", {
@@ -77,7 +97,10 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             const typed = isRecord(input) ? input : {};
             const pattern = typeof typed.pattern === "string" ? typed.pattern : "";
             const targetPath = typeof typed.path === "string" ? typed.path : "/";
-            const infos = (await Promise.resolve(backend.globInfo?.(pattern, targetPath))) ?? [];
+            const legacyInfos = (await Promise.resolve(backend.globInfo?.(pattern, targetPath))) ?? [];
+            const infos = legacyInfos.length > 0
+                ? legacyInfos
+                : ((await Promise.resolve(backend.glob?.(pattern, targetPath)))?.files ?? []);
             if (infos.length === 0) {
                 return `No files found matching pattern '${pattern}'`;
             }
@@ -93,16 +116,23 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         }).passthrough(),
         invoke: async (input) => {
             const typed = isRecord(input) ? input : {};
-            const result = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
-            if (typeof result === "string") {
-                return result;
+            const legacyResult = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
+            const structuredResult = await Promise.resolve(backend.grep?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
+            const normalizedStructuredMatches = structuredResult?.matches?.map((match) => ({
+                path: match.path,
+                line: match.lineNumber ?? match.line_number ?? match.line ?? 0,
+                text: match.content ?? match.text ?? "",
+            }));
+            const normalizedResult = legacyResult ?? normalizedStructuredMatches;
+            if (typeof normalizedResult === "string") {
+                return normalizedResult;
             }
-            if (!result || result.length === 0) {
+            if (!normalizedResult || normalizedResult.length === 0) {
                 return `No matches found for pattern '${typeof typed.pattern === "string" ? typed.pattern : ""}'`;
             }
             const lines = [];
             let currentFile = "";
-            for (const match of result) {
+            for (const match of normalizedResult) {
                 if (match.path !== currentFile) {
                     currentFile = match.path;
                     lines.push(`\n${currentFile}:`);

package/dist/runtime/adapter/tool/declared-middleware.js

@@ -1,5 +1,5 @@
 import { anthropicPromptCachingMiddleware, contextEditingMiddleware, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, summarizationMiddleware, todoListMiddleware, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, } from "langchain";
-import { createFilesystemMiddleware, createPatchToolCallsMiddleware, createSummarizationMiddleware as createDeepAgentSummarizationMiddleware, } from "deepagents";
+import { createCompletionCallbackMiddleware, createFilesystemMiddleware, createPatchToolCallsMiddleware, createSummarizationMiddleware as createDeepAgentSummarizationMiddleware, } from "deepagents";
 function asMiddlewareConfig(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : null;
 }
@@ -84,6 +84,7 @@ async function createFilesystemDeclarativeMiddleware({ config, resolveFilesystem
     return createFilesystemMiddleware(runtimeConfig);
 }
 export const DECLARATIVE_MIDDLEWARE_REGISTRY = {
+    completionCallback: async ({ config }) => createCompletionCallbackMiddleware(config),
     filesystem: createFilesystemDeclarativeMiddleware,
     patchToolCalls: async () => createPatchToolCallsMiddleware(),
     summarization: createBindingAwareSummarizationMiddleware,

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, MessageContent, RunResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
+import type { CompiledAgentBinding, CompiledAsyncSubAgent, MessageContent, RunResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
 import { type UpstreamSubagentConfig } from "./adapter/middleware-assembly.js";
@@ -36,7 +36,7 @@ export declare function buildDeepAgentCreateParams(input: {
     resolvedModel: unknown;
     resolvedTools: unknown[];
     resolvedMiddleware: unknown[];
-    resolvedSubagents: UpstreamSubagentConfig[];
+    resolvedSubagents: Array<UpstreamSubagentConfig | CompiledAsyncSubAgent>;
     resolvedCheckpointer?: unknown;
     resolvedStore?: unknown;
     resolvedBackend?: unknown;
@@ -73,6 +73,7 @@ export declare class AgentRuntimeAdapter {
     private resolveLangChainRuntimeExtensionMiddleware;
     private resolveMiddleware;
     private resolveSubagents;
+    private resolveDeepAgentSubagents;
     private createLangChainRunnable;
     private createRunnable;
     private createDeepAgentRunnable;

package/dist/runtime/agent-runtime-adapter.js

@@ -18,7 +18,7 @@ export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillS
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingBackendConfig, getBindingAdapterKind, getBindingExecutionKind, getBindingExecutionParams, getBindingFilesystemConfig, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryModel, getBindingSkills, getBindingStoreConfig, getBindingSubagents, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingBackendConfig, getBindingAdapterKind, getBindingDeepAgentSubagents, getBindingExecutionKind, getBindingExecutionParams, getBindingFilesystemConfig, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryModel, getBindingSkills, getBindingStoreConfig, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "write_todos",
@@ -372,6 +372,12 @@ export class AgentRuntimeAdapter {
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
         });
     }
+    async resolveDeepAgentSubagents(subagents, binding) {
+        const syncSubagents = subagents.filter((subagent) => !("graphId" in subagent));
+        const asyncSubagents = subagents.filter((subagent) => "graphId" in subagent);
+        const resolvedSyncSubagents = await this.resolveSubagents(syncSubagents, binding);
+        return [...resolvedSyncSubagents, ...asyncSubagents];
+    }
     async createLangChainRunnable(binding, options = {}) {
         const executionKind = getBindingExecutionKind(binding);
         const primaryModel = getBindingPrimaryModel(binding);
@@ -419,7 +425,7 @@ export class AgentRuntimeAdapter {
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
         const resolvedMiddleware = await this.resolveMiddleware(binding);
-        const resolvedSubagents = await this.resolveSubagents(getBindingSubagents(binding), binding);
+        const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding);
         const resolvedInterruptOn = resolveRunnableInterruptOn(binding);
         const substrateMode = this.options.deepAgentUpstreamSubstrateMode ?? "minimal";
         const resolvedCheckpointer = substrateMode === "minimal"

package/dist/runtime/support/compiled-binding.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LegacyDeepAgentParams, LegacyLangChainAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledDeepAgentSubAgent, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LegacyDeepAgentParams, LegacyLangChainAgentParams, LangChainAgentParams } from "../../contracts/types.js";
 export type BindingExecutionView = {
     adapterKind: string;
     langchainParams?: LegacyLangChainAgentParams;
@@ -27,6 +27,7 @@ export declare function withUpdatedBindingExecutionParams(binding: CompiledAgent
 export declare function getBindingSkills(binding: CompiledAgentBinding): string[];
 export declare function getBindingMemorySources(binding: CompiledAgentBinding): string[];
 export declare function getBindingSubagents(binding: CompiledAgentBinding): CompiledSubAgent[];
+export declare function getBindingDeepAgentSubagents(binding: CompiledAgentBinding): CompiledDeepAgentSubAgent[];
 export declare function getBindingGeneralPurposeAgent(binding: CompiledAgentBinding): boolean | undefined;
 export declare function getBindingTaskDescription(binding: CompiledAgentBinding): string | undefined;
 export declare function getBindingBackendConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;

package/dist/runtime/support/compiled-binding.js

@@ -202,6 +202,12 @@ export function getBindingSubagents(binding) {
         ? (execution.subagents)
         : [];
 }
+export function getBindingDeepAgentSubagents(binding) {
+    const execution = getBindingExecutionParams(binding);
+    return Array.isArray(execution?.subagents)
+        ? (execution.subagents)
+        : [];
+}
 export function getBindingGeneralPurposeAgent(binding) {
     const langchainGeneralPurposeAgent = binding.harnessRuntime?.langchain?.generalPurposeAgent;
     if (typeof langchainGeneralPurposeAgent === "boolean") {

package/dist/workspace/agent-binding-compiler.js

@@ -215,6 +215,21 @@ function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledA
         return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel);
     });
 }
+function compileAsyncSubagents(agent) {
+    return (agent.asyncSubagents ?? []).map((subagent) => ({
+        name: subagent.name,
+        description: subagent.description,
+        graphId: subagent.graphId,
+        ...(subagent.url ? { url: subagent.url } : {}),
+        ...(subagent.headers ? { headers: { ...subagent.headers } } : {}),
+    }));
+}
+function compileDeepAgentSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel) {
+    return [
+        ...compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
+        ...compileAsyncSubagents(agent),
+    ];
+}
 function compileExecutionCore(agent, models, tools) {
     return {
         model: requireModel(models, agent.modelRef, agent.id),
@@ -420,7 +435,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             responseFormat: executionCore.responseFormat,
             contextSchema: executionCore.contextSchema,
             middleware: executionCore.middleware,
-            subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
+            subagents: compileDeepAgentSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
             interruptOn: resolveInterruptOn(agent),
             ...(backend ? { backend: backend.config } : {}),
             ...(store ? { store: store.config } : {}),

package/dist/workspace/object-loader.js

@@ -87,6 +87,37 @@ function readRefArray(items) {
             : undefined)
         .filter((item) => Boolean(item));
 }
+function readStringRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value)
+        .filter((entry) => typeof entry[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function readAsyncSubAgentArray(items) {
+    return toArray(items)
+        .flatMap((item) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            return [];
+        }
+        const typed = item;
+        const name = typeof typed.name === "string" ? typed.name.trim() : "";
+        const description = typeof typed.description === "string" ? typed.description.trim() : "";
+        const graphId = typeof typed.graphId === "string" ? typed.graphId.trim() : "";
+        if (!name || !description || !graphId) {
+            return [];
+        }
+        const headers = readStringRecord(typed.headers);
+        return [{
+                name,
+                description,
+                graphId,
+                ...(typeof typed.url === "string" && typed.url.trim().length > 0 ? { url: typed.url.trim() } : {}),
+                ...(headers ? { headers } : {}),
+            }];
+    });
+}
 function readPrefixedRefArray(items, prefix) {
     return toArray(items)
         .map((item) => {
@@ -472,6 +503,7 @@ export function parseAgentItem(item, sourcePath) {
     const subagentPathRefs = readExecutionValue(normalizedItem, "subagents", readPathArray)
         .filter((entry) => path.isAbsolute(entry) || entry.startsWith("./") || entry.startsWith("../"))
         .map((entry) => resolveModuleRelativePath(entry, moduleRoot));
+    const asyncSubagents = readExecutionValue(normalizedItem, "subagents", readAsyncSubAgentArray);
     const executionMode = String(resolveExecutionBackend(normalizedItem) ?? "deepagent");
     const runtime = readRuntimeConfig(normalizedItem);
     return {
@@ -492,6 +524,7 @@ export function parseAgentItem(item, sourcePath) {
         memorySources: readExecutionValue(normalizedItem, "memory", readPathArray).map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
         subagentRefs,
         subagentPathRefs,
+        asyncSubagents,
         langchainAgentConfig: normalizeModuleAgentConfig(readAgentConfig(normalizedItem, { includeDelegationControls: true }), moduleRoot),
         deepAgentConfig: normalizeModuleAgentConfig(readAgentConfig(normalizedItem, {
             includeObjectBackend: true,

package/dist/workspace/validate.js

@@ -39,6 +39,9 @@ function validateMiddlewareConfig(agent) {
         if (kind === "humanInTheLoop" && typeof typed.interruptOn !== "object") {
             throw new Error(`Agent ${agent.id} humanInTheLoop middleware requires interruptOn`);
         }
+        if (kind === "completionCallback" && typeof typed.callbackGraphId !== "string") {
+            throw new Error(`Agent ${agent.id} completionCallback middleware requires callbackGraphId`);
+        }
         if (kind === "filesystem" && agent.executionMode === "deepagent") {
             throw new Error(`Agent ${agent.id} cannot use filesystem middleware with DeepAgents; configure filesystem behavior through the deepagent backend instead`);
         }
@@ -48,6 +51,7 @@ function validateMiddlewareConfig(agent) {
     }
 }
 export function validateAgent(agent) {
+    const asyncSubagents = agent.asyncSubagents ?? [];
     if (!agent.id) {
         throw new Error(`Agent id is required in ${agent.sourcePath}`);
     }
@@ -60,9 +64,12 @@ export function validateAgent(agent) {
     if (!isMemoryCapableAgent(agent) && agent.memorySources.length > 0) {
         throw new Error(`Agent ${agent.id} cannot define memory unless it uses a memory-capable backend`);
     }
-    if ((agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0) && !isDelegationCapableAgent(agent)) {
+    if ((agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0 || asyncSubagents.length > 0) && !isDelegationCapableAgent(agent)) {
         throw new Error(`Agent ${agent.id} must use a delegation-capable backend when subagents are defined`);
     }
+    if (asyncSubagents.length > 0 && agent.executionMode !== "deepagent") {
+        throw new Error(`Agent ${agent.id} async subagents require backend=deepagent`);
+    }
     validateCheckpointerConfig(agent);
     validateMiddlewareConfig(agent);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.227",
+  "version": "0.0.229",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",