@botbotgo/agent-harness 0.0.42 → 0.0.44

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

@@ -0,0 +1,15 @@
+import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
+export declare function getBindingAdapterConfig(binding: CompiledAgentBinding): Record<string, unknown>;
+export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LangChainAgentParams | undefined;
+export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): DeepAgentParams | undefined;
+export declare function isLangChainBinding(binding: CompiledAgentBinding): boolean;
+export declare function isDeepAgentBinding(binding: CompiledAgentBinding): boolean;
+export declare function getBindingPrimaryTools(binding: CompiledAgentBinding): CompiledTool[];
+export declare function getBindingPrimaryModel(binding: CompiledAgentBinding): CompiledModel | undefined;
+export declare function getBindingSystemPrompt(binding: CompiledAgentBinding): string | undefined;
+export declare function getBindingMiddlewareConfigs(binding: CompiledAgentBinding): Array<Record<string, unknown>> | undefined;
+export declare function getBindingInterruptCompatibilityRules(binding: CompiledAgentBinding): Record<string, boolean | object> | undefined;
+export declare function getBindingModelInit(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
+export declare function getBindingStoreConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
+export declare function bindingHasSubagents(binding: CompiledAgentBinding): boolean;

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

@@ -0,0 +1,56 @@
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function getBindingAdapterKind(binding) {
+    return binding.adapter?.kind ?? binding.agent.executionMode;
+}
+export function getBindingAdapterConfig(binding) {
+    return binding.adapter?.config ?? {};
+}
+export function getBindingLangChainParams(binding) {
+    const adapterParams = asRecord(getBindingAdapterConfig(binding).params);
+    if (getBindingAdapterKind(binding) === "langchain-v1" && adapterParams) {
+        return adapterParams;
+    }
+    return binding.langchainAgentParams;
+}
+export function getBindingDeepAgentParams(binding) {
+    const adapterParams = asRecord(getBindingAdapterConfig(binding).params);
+    if (getBindingAdapterKind(binding) === "deepagent" && adapterParams) {
+        return adapterParams;
+    }
+    return binding.deepAgentParams;
+}
+export function isLangChainBinding(binding) {
+    return getBindingAdapterKind(binding) === "langchain-v1" || Boolean(binding.langchainAgentParams);
+}
+export function isDeepAgentBinding(binding) {
+    return getBindingAdapterKind(binding) === "deepagent" || Boolean(binding.deepAgentParams);
+}
+export function getBindingPrimaryTools(binding) {
+    return binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? [];
+}
+export function getBindingPrimaryModel(binding) {
+    return binding.langchainAgentParams?.model ?? binding.deepAgentParams?.model;
+}
+export function getBindingSystemPrompt(binding) {
+    return binding.langchainAgentParams?.systemPrompt ?? binding.deepAgentParams?.systemPrompt;
+}
+export function getBindingMiddlewareConfigs(binding) {
+    return binding.langchainAgentParams?.middleware ?? binding.deepAgentParams?.middleware;
+}
+export function getBindingInterruptCompatibilityRules(binding) {
+    return binding.deepAgentParams?.interruptOn ??
+        binding.agent.langchainAgentConfig?.interruptOn;
+}
+export function getBindingModelInit(binding) {
+    return getBindingPrimaryModel(binding)?.init;
+}
+export function getBindingStoreConfig(binding) {
+    return binding.deepAgentParams?.store ?? binding.harnessRuntime.store;
+}
+export function bindingHasSubagents(binding) {
+    return (binding.deepAgentParams?.subagents.length ?? 0) > 0;
+}

package/dist/runtime/support/harness-support.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, HarnessEvent, WorkspaceBundle } from "../../contracts/types.js";
+import type { HarnessEvent, InternalApprovalRecord, WorkspaceBundle } from "../../contracts/types.js";
 export declare function renderRuntimeFailure(error: unknown): string;
 export declare function renderToolFailure(toolName: string, output: unknown): string;
 export declare function parseInterruptContent(content: string): {
@@ -19,7 +19,7 @@ export declare function heuristicRoute(input: string, primaryBinding?: {
     };
 }): string;
 export declare function createHarnessEvent(threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]): HarnessEvent;
-export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): ApprovalRecord;
+export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): InternalApprovalRecord;
 export declare function inferRoutingBindings(workspace: WorkspaceBundle): {
     primaryBinding: import("../../contracts/types.js").CompiledAgentBinding;
     secondaryBinding: import("../../contracts/types.js").CompiledAgentBinding | undefined;

package/dist/runtime/support/harness-support.js

@@ -1,4 +1,5 @@
 import { createPersistentId } from "../../utils/id.js";
+import { isDelegationCapableBinding } from "../../workspace/support/agent-capabilities.js";
 export function renderRuntimeFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `runtime_error=${message}`.trim();
@@ -131,20 +132,21 @@ export function inferRoutingBindings(workspace) {
     const hostBindings = Array.from(workspace.bindings.values()).filter((binding) => binding.harnessRuntime.hostFacing);
     const researchBinding = hostBindings.find((binding) => binding.agent.id === "research-lite" || binding.agent.id === "research");
     const directBinding = hostBindings.find((binding) => binding.agent.id === "direct");
-    const langchainHost = hostBindings.find((binding) => binding.agent.executionMode === "langchain-v1" && binding.agent.id !== researchBinding?.agent.id);
-    const deepagentHosts = hostBindings.filter((binding) => binding.agent.executionMode === "deepagent");
-    const defaultDeepagentHost = deepagentHosts.find((binding) => binding.agent.id === "orchestra") ??
-        deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        deepagentHosts[0];
-    const deepagentWithSubagents = deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        deepagentHosts[0];
-    const primaryBinding = defaultDeepagentHost ?? directBinding ?? langchainHost ?? hostBindings[0];
-    const secondaryBinding = langchainHost && langchainHost.agent.id !== primaryBinding?.agent.id
-        ? langchainHost
+    const delegationHosts = hostBindings.filter((binding) => isDelegationCapableBinding(binding));
+    const lightweightHosts = hostBindings.filter((binding) => !isDelegationCapableBinding(binding));
+    const defaultOrchestratingHost = hostBindings.find((binding) => binding.agent.id === "orchestra") ??
+        delegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        delegationHosts[0];
+    const delegationPreferredSecondary = delegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        delegationHosts[0];
+    const genericLightweightHost = lightweightHosts.find((binding) => binding.agent.id !== researchBinding?.agent.id);
+    const primaryBinding = defaultOrchestratingHost ?? directBinding ?? genericLightweightHost ?? hostBindings[0];
+    const secondaryBinding = genericLightweightHost && genericLightweightHost.agent.id !== primaryBinding?.agent.id
+        ? genericLightweightHost
         : directBinding && directBinding.agent.id !== primaryBinding?.agent.id
             ? directBinding
-            : deepagentWithSubagents && deepagentWithSubagents.agent.id !== primaryBinding?.agent.id
-                ? deepagentWithSubagents
+            : delegationPreferredSecondary && delegationPreferredSecondary.agent.id !== primaryBinding?.agent.id
+                ? delegationPreferredSecondary
                 : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id);
     return { primaryBinding, secondaryBinding, researchBinding, hostBindings };
 }

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

@@ -1,8 +1,9 @@
 import path from "node:path";
 import { getSkillInheritancePolicy, resolveToolTargets } from "../extensions.js";
 import { compileModel, compileTool } from "./resource-compilers.js";
+import { inferAgentCapabilities } from "./support/agent-capabilities.js";
 import { discoverSkillPaths } from "./support/discovery.js";
-import { compileAgentMemories, getRuntimeDefaults, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.js";
+import { compileAgentMemories, getRuntimeDefaults, getWorkspaceObject, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.js";
 const WORKSPACE_BOUNDARY_GUIDANCE = "Keep repository and file exploration bounded to the current workspace root unless the user explicitly asks for broader host or filesystem access. " +
     "Do not inspect absolute paths outside the workspace, system directories, or unrelated repos by default. " +
     "Prefer workspace-local tools, relative paths, and the current repository checkout when analyzing code.";
@@ -132,15 +133,50 @@ function resolveBackendConfig(agent) {
         : undefined;
     return backendConfig ? { config: backendConfig } : undefined;
 }
-function resolveStoreConfig(agent) {
+function isRefConfig(value) {
+    if (typeof value?.ref !== "string" || value.ref.trim().length === 0) {
+        return false;
+    }
+    return Object.keys(value).every((key) => key === "ref");
+}
+function materializeWorkspaceObjectConfig(refs, ref, allowedKinds, ownerLabel) {
+    const object = getWorkspaceObject(refs, ref);
+    if (!object) {
+        throw new Error(`${ownerLabel} references missing object ${ref}`);
+    }
+    if (!allowedKinds.includes(object.kind)) {
+        throw new Error(`${ownerLabel} references ${ref}, but expected one of: ${allowedKinds.join(", ")}`);
+    }
+    const { id: _id, kind: _kind, ...config } = object.value;
+    if (object.kind === "store") {
+        const storeKind = typeof config.storeKind === "string" ? config.storeKind : undefined;
+        const { storeKind: _storeKind, ...rest } = config;
+        return storeKind ? { kind: storeKind, ...rest } : config;
+    }
+    if (object.kind === "checkpointer" || object.kind === "file-checkpointer" || object.kind === "sqlite-saver") {
+        const checkpointerKind = typeof config.checkpointerKind === "string" ? config.checkpointerKind : undefined;
+        const { checkpointerKind: _checkpointerKind, ...rest } = config;
+        return checkpointerKind ? { kind: checkpointerKind, ...rest } : config;
+    }
+    return config;
+}
+function resolveStoreConfig(agent, refs) {
     const inlineStore = typeof agent.deepAgentConfig?.store === "object" && agent.deepAgentConfig.store
         ? agent.deepAgentConfig.store
         : typeof agent.langchainAgentConfig?.store === "object" && agent.langchainAgentConfig.store
             ? agent.langchainAgentConfig.store
             : undefined;
-    return inlineStore ? { config: inlineStore } : undefined;
+    if (!inlineStore) {
+        return undefined;
+    }
+    if (isRefConfig(inlineStore)) {
+        return {
+            config: materializeWorkspaceObjectConfig(refs, inlineStore.ref, ["store"], `Agent ${agent.id} store`),
+        };
+    }
+    return { config: inlineStore };
 }
-function resolveCheckpointerConfig(agent) {
+function resolveCheckpointerConfig(agent, refs) {
     const inlineAgentCheckpointer = typeof agent.deepAgentConfig?.checkpointer === "object" && agent.deepAgentConfig.checkpointer
         ? agent.deepAgentConfig.checkpointer
         : typeof agent.deepAgentConfig?.checkpointer === "boolean"
@@ -150,7 +186,18 @@ function resolveCheckpointerConfig(agent) {
                 : typeof agent.langchainAgentConfig?.checkpointer === "boolean"
                     ? agent.langchainAgentConfig.checkpointer
                     : undefined;
-    return inlineAgentCheckpointer !== undefined ? { config: inlineAgentCheckpointer } : undefined;
+    if (inlineAgentCheckpointer === undefined) {
+        return undefined;
+    }
+    if (typeof inlineAgentCheckpointer === "boolean") {
+        return { config: inlineAgentCheckpointer };
+    }
+    if (isRefConfig(inlineAgentCheckpointer)) {
+        return {
+            config: materializeWorkspaceObjectConfig(refs, inlineAgentCheckpointer.ref, ["checkpointer", "file-checkpointer", "sqlite-saver"], `Agent ${agent.id} checkpointer`),
+        };
+    }
+    return { config: inlineAgentCheckpointer };
 }
 export function compileBinding(workspaceRoot, agent, agents, referencedSubagentIds, refs, models, tools) {
     const internalSubagent = referencedSubagentIds.has(agent.id);
@@ -159,8 +206,8 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const compiledAgentMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
     const compiledAgentModel = requireModel(models, agent.modelRef || (internalSubagent ? "model/default" : ""), agent.id);
     const backend = resolveBackendConfig(agent);
-    const store = resolveStoreConfig(agent);
-    const checkpointer = resolveCheckpointerConfig(agent);
+    const store = resolveStoreConfig(agent, refs);
+    const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
         ? path.resolve(workspaceRoot, agent.runRoot)
         : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
@@ -168,10 +215,21 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             : path.join(workspaceRoot, "run-data");
     const base = {
         agent,
+        adapter: {
+            kind: agent.executionMode,
+            config: agent.executionMode === "deepagent"
+                ? {
+                    deepAgent: true,
+                }
+                : {
+                    langchainV1: true,
+                },
+        },
         harnessRuntime: {
             runRoot,
             workspaceRoot,
             hostFacing: !internalSubagent,
+            capabilities: inferAgentCapabilities(agent),
             ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
             ...(store ? { store: store.config } : {}),
         },
@@ -194,37 +252,50 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         };
         return {
             ...base,
+            adapter: {
+                kind: "langchain-v1",
+                config: {
+                    params: langchainAgentParams,
+                },
+            },
             langchainAgentParams,
             directAgentParams: langchainAgentParams,
         };
     }
+    const deepAgentParams = {
+        model: compiledAgentModel,
+        tools: requireTools(tools, agent.toolRefs, agent.id),
+        systemPrompt: resolveSystemPrompt(agent),
+        responseFormat: agent.deepAgentConfig?.responseFormat,
+        contextSchema: agent.deepAgentConfig?.contextSchema,
+        middleware: compileMiddlewareConfigs(agent.deepAgentConfig?.middleware, models, agent.id),
+        description: agent.description,
+        subagents: agent.subagentRefs.map((ref) => {
+            const subagent = agents.get(resolveRefId(ref));
+            if (!subagent) {
+                throw new Error(`Missing subagent ${ref} for agent ${agent.id}`);
+            }
+            return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory);
+        }),
+        interruptOn: resolveInterruptOn(agent),
+        ...(backend ? { backend: backend.config } : {}),
+        ...(store ? { store: store.config } : {}),
+        name: resolveAgentRuntimeName(agent),
+        memory: compiledAgentMemory,
+        skills: compiledAgentSkills,
+        generalPurposeAgent: typeof agent.deepAgentConfig?.generalPurposeAgent === "boolean" ? agent.deepAgentConfig.generalPurposeAgent : undefined,
+        taskDescription: typeof agent.deepAgentConfig?.taskDescription === "string" && agent.deepAgentConfig.taskDescription.trim()
+            ? agent.deepAgentConfig.taskDescription
+            : undefined,
+    };
     return {
         ...base,
-        deepAgentParams: {
-            model: compiledAgentModel,
-            tools: requireTools(tools, agent.toolRefs, agent.id),
-            systemPrompt: resolveSystemPrompt(agent),
-            responseFormat: agent.deepAgentConfig?.responseFormat,
-            contextSchema: agent.deepAgentConfig?.contextSchema,
-            middleware: compileMiddlewareConfigs(agent.deepAgentConfig?.middleware, models, agent.id),
-            description: agent.description,
-            subagents: agent.subagentRefs.map((ref) => {
-                const subagent = agents.get(resolveRefId(ref));
-                if (!subagent) {
-                    throw new Error(`Missing subagent ${ref} for agent ${agent.id}`);
-                }
-                return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory);
-            }),
-            interruptOn: resolveInterruptOn(agent),
-            ...(backend ? { backend: backend.config } : {}),
-            ...(store ? { store: store.config } : {}),
-            name: resolveAgentRuntimeName(agent),
-            memory: compiledAgentMemory,
-            skills: compiledAgentSkills,
-            generalPurposeAgent: typeof agent.deepAgentConfig?.generalPurposeAgent === "boolean" ? agent.deepAgentConfig.generalPurposeAgent : undefined,
-            taskDescription: typeof agent.deepAgentConfig?.taskDescription === "string" && agent.deepAgentConfig.taskDescription.trim()
-                ? agent.deepAgentConfig.taskDescription
-                : undefined,
+        adapter: {
+            kind: "deepagent",
+            config: {
+                params: deepAgentParams,
+            },
         },
+        deepAgentParams,
     };
 }

package/dist/workspace/object-loader.js

@@ -88,6 +88,8 @@ function normalizeNamedResourceSpec(document, kind) {
 }
 function normalizeKind(kind) {
     switch (kind) {
+        case "Agent":
+            return "agent";
         case "LangChainAgent":
             return "langchain-agent";
         case "DeepAgent":
@@ -209,6 +211,37 @@ function readObjectArray(items) {
         .map((item) => ({ ...item }));
     return records.length > 0 ? records : undefined;
 }
+function readCapabilities(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const typed = value;
+    const capabilities = {
+        ...(typeof typed.delegation === "boolean" ? { delegation: typed.delegation } : {}),
+        ...(typeof typed.memory === "boolean" ? { memory: typed.memory } : {}),
+    };
+    return Object.keys(capabilities).length > 0 ? capabilities : undefined;
+}
+function readExecutionConfig(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : undefined;
+}
+function resolveExecutionBackend(item, current) {
+    const execution = readExecutionConfig(item.execution) ?? readExecutionConfig(current?.execution);
+    const backend = typeof execution?.backend === "string"
+        ? execution.backend.trim().toLowerCase()
+        : typeof execution?.mode === "string"
+            ? execution.mode.trim().toLowerCase()
+            : undefined;
+    if (backend === "langchain-v1" || backend === "langchain" || backend === "langchain-agent") {
+        return "langchain-v1";
+    }
+    if (backend === "deepagent" || backend === "deepagents") {
+        return "deepagent";
+    }
+    return undefined;
+}
 function readSharedAgentConfig(item) {
     const middleware = readMiddlewareArray(item.middleware);
     return {
@@ -244,12 +277,16 @@ export function parseAgentItem(item, sourcePath) {
     const subagentRefs = readRefArray(item.subagents);
     const subagentPathRefs = readPathArray(item.subagents);
     const kind = typeof item.kind === "string" ? item.kind : "agent";
-    const executionMode = String((kind === "langchain-agent" ? "langchain-v1" : undefined) ??
+    const executionMode = String(resolveExecutionBackend(item) ??
+        (kind === "langchain-agent" ? "langchain-v1" : undefined) ??
         (kind === "deepagent" ? "deepagent" : undefined) ??
         "deepagent");
     return {
         id: String(item.id),
         executionMode: executionMode,
+        capabilities: readCapabilities(item.capabilities) ?? (executionMode === "deepagent"
+            ? { delegation: true, memory: true }
+            : { delegation: false, memory: false }),
         description: String(item.description ?? ""),
         modelRef: readSingleRef(item.modelRef) ?? "",
         runRoot: typeof item.runRoot === "string" ? item.runRoot : undefined,
@@ -460,16 +497,26 @@ async function readNamedModelItems(root) {
         }
         const parsedDocuments = parseAllDocuments(await readYamlOrJson(filePath));
         for (const parsedDocument of parsedDocuments) {
-            const items = normalizeNamedResourceSpec(parsedDocument.toJSON(), "model");
-            for (const item of items) {
-                records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
+            const document = parsedDocument.toJSON();
+            const catalogItems = normalizeNamedResourceSpec(document, "model");
+            if (catalogItems.length > 0) {
+                for (const item of catalogItems) {
+                    records.push({ item: normalizeYamlItem(item), sourcePath: filePath });
+                }
+                continue;
+            }
+            for (const item of await objectItemsFromDocument(document, filePath)) {
+                const normalized = normalizeYamlItem(item);
+                if (normalized.kind === "model" && typeof normalized.id === "string" && normalized.id.trim()) {
+                    records.push({ item: normalized, sourcePath: filePath });
+                }
             }
         }
     }
     return records;
 }
 function isAgentKind(kind) {
-    return kind === "deepagent" || kind === "langchain-agent";
+    return kind === "deepagent" || kind === "langchain-agent" || kind === "agent";
 }
 async function readConfigAgentItems(configRoot) {
     const records = await readYamlItems(configRoot, "agents", { recursive: true });
@@ -517,6 +564,10 @@ export async function readToolModuleItems(root) {
     return records;
 }
 function inferExecutionMode(item, current) {
+    const explicitExecution = resolveExecutionBackend(item, current);
+    if (explicitExecution) {
+        return explicitExecution;
+    }
     const kind = typeof item.kind === "string" ? item.kind : typeof current?.kind === "string" ? current.kind : undefined;
     if (kind === "langchain-agent") {
         return "langchain-v1";

package/dist/workspace/support/agent-capabilities.d.ts

@@ -0,0 +1,9 @@
+import type { CompiledAgentBinding, ParsedAgentObject, RuntimeCapabilities } from "../../contracts/types.js";
+export declare function inferAgentCapabilities(agent: ParsedAgentObject): RuntimeCapabilities;
+export declare function inferBindingCapabilities(binding: CompiledAgentBinding): RuntimeCapabilities;
+export declare function isDelegationCapableAgent(agent: ParsedAgentObject): boolean;
+export declare function isMemoryCapableAgent(agent: ParsedAgentObject): boolean;
+export declare function isDelegationCapableBinding(binding: CompiledAgentBinding): boolean;
+export declare function isMemoryCapableBinding(binding: CompiledAgentBinding): boolean;
+export declare function getAgentSystemPrompt(agent: ParsedAgentObject): string | undefined;
+export declare function hasAgentSystemPrompt(agent: ParsedAgentObject): boolean;

package/dist/workspace/support/agent-capabilities.js

@@ -0,0 +1,41 @@
+function normalizeCapabilities(capabilities) {
+    return {
+        delegation: capabilities?.delegation === true,
+        memory: capabilities?.memory === true,
+    };
+}
+export function inferAgentCapabilities(agent) {
+    if (agent.capabilities) {
+        return normalizeCapabilities(agent.capabilities);
+    }
+    return {
+        delegation: agent.executionMode === "deepagent",
+        memory: agent.executionMode === "deepagent",
+    };
+}
+export function inferBindingCapabilities(binding) {
+    return normalizeCapabilities(binding.harnessRuntime.capabilities ?? binding.agent.capabilities ?? inferAgentCapabilities(binding.agent));
+}
+export function isDelegationCapableAgent(agent) {
+    return inferAgentCapabilities(agent).delegation === true;
+}
+export function isMemoryCapableAgent(agent) {
+    return inferAgentCapabilities(agent).memory === true;
+}
+export function isDelegationCapableBinding(binding) {
+    return inferBindingCapabilities(binding).delegation === true;
+}
+export function isMemoryCapableBinding(binding) {
+    return inferBindingCapabilities(binding).memory === true;
+}
+export function getAgentSystemPrompt(agent) {
+    const deepagentPrompt = typeof agent.deepAgentConfig?.systemPrompt === "string" ? agent.deepAgentConfig.systemPrompt.trim() : "";
+    if (deepagentPrompt) {
+        return deepagentPrompt;
+    }
+    const langchainPrompt = typeof agent.langchainAgentConfig?.systemPrompt === "string" ? agent.langchainAgentConfig.systemPrompt.trim() : "";
+    return langchainPrompt || undefined;
+}
+export function hasAgentSystemPrompt(agent) {
+    return typeof getAgentSystemPrompt(agent) === "string";
+}

package/dist/workspace/validate.js

@@ -1,7 +1,5 @@
+import { hasAgentSystemPrompt, isDelegationCapableAgent, isMemoryCapableAgent, } from "./support/agent-capabilities.js";
 const allowedExecutionModes = new Set(["deepagent", "langchain-v1"]);
-function hasPromptContent(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
 function validateCheckpointerConfig(agent) {
     const checkpointer = (typeof agent.deepAgentConfig?.checkpointer === "object" && agent.deepAgentConfig.checkpointer) ||
         (typeof agent.deepAgentConfig?.checkpointer === "boolean" ? agent.deepAgentConfig.checkpointer : undefined) ||
@@ -52,14 +50,14 @@ export function validateAgent(agent) {
     if (!agent.description.trim()) {
         throw new Error(`Agent ${agent.id} description must not be empty`);
     }
-    if (agent.executionMode === "langchain-v1" && (agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0)) {
-        throw new Error(`Agent ${agent.id} cannot define subagents unless execution.mode is deepagent`);
+    if (!isDelegationCapableAgent(agent) && (agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0)) {
+        throw new Error(`Agent ${agent.id} cannot define subagents unless it uses a delegation-capable backend`);
     }
-    if (agent.executionMode === "langchain-v1" && agent.memorySources.length > 0) {
-        throw new Error(`Agent ${agent.id} cannot define memory unless execution.mode is deepagent`);
+    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) && agent.executionMode !== "deepagent") {
-        throw new Error(`Agent ${agent.id} must use deepagent execution when subagents are defined`);
+    if ((agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0) && !isDelegationCapableAgent(agent)) {
+        throw new Error(`Agent ${agent.id} must use a delegation-capable backend when subagents are defined`);
     }
     validateCheckpointerConfig(agent);
     validateMiddlewareConfig(agent);
@@ -83,11 +81,11 @@ export function validateTopology(agents) {
         if (!referencedSubagentIds.has(agent.id)) {
             continue;
         }
-        if (agent.executionMode !== "deepagent") {
-            throw new Error(`Subagent ${agent.id} must use deepagent execution`);
+        if (!isDelegationCapableAgent(agent)) {
+            throw new Error(`Subagent ${agent.id} must use a delegation-capable backend`);
         }
-        if (!hasPromptContent(agent.deepAgentConfig?.systemPrompt)) {
-            throw new Error(`Subagent ${agent.id} requires deepagent.systemPrompt`);
+        if (!hasAgentSystemPrompt(agent)) {
+            throw new Error(`Subagent ${agent.id} requires systemPrompt`);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -26,6 +26,11 @@
       "types": "./dist/tools.d.ts",
       "import": "./dist/tools.js",
       "default": "./dist/tools.js"
+    },
+    "./presentation": {
+      "types": "./dist/presentation.d.ts",
+      "import": "./dist/presentation.js",
+      "default": "./dist/presentation.js"
     }
   },
   "dependencies": {
@@ -50,8 +55,9 @@
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",
     "check": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run test/public-api.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/runtime-adapter-regressions.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts",
+    "test": "vitest run test/public-api.test.ts test/resource-optional-provider.test.ts test/resource-isolation.test.ts test/stock-research-app-load-harness.test.ts test/stock-research-app-run.test.ts test/release-workflow.test.ts test/release-version.test.ts test/gitignore.test.ts test/package-lock.test.ts test/readme.test.ts test/runtime-adapter-regressions.test.ts test/runtime-recovery.test.ts test/tool-extension-gaps.test.ts test/checkpoint-maintenance.test.ts test/llamaindex-dependency-compat.test.ts test/skill-standard.test.ts test/routing-config.test.ts test/workspace-compat-regressions.test.ts test/upstream-compat-regressions.test.ts test/embedded-browser-bookmarks.test.ts test/presentation-wallee.test.ts",
     "test:real-providers": "vitest run test/real-provider-harness.test.ts",
+    "test:integration": "npm run build && node scripts/integration-wallee-browser.mjs",
     "release:prepare": "npm version patch --no-git-tag-version && node ./scripts/sync-example-version.mjs",
     "release:pack": "npm pack --dry-run",
     "release:publish": "npm publish --access public --registry https://registry.npmjs.org/"