@botbotgo/agent-harness 0.0.227 → 0.0.228

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.227";

package/dist/package-version.js

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

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

@@ -48,6 +48,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 +61,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.228",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",