@botbotgo/agent-harness 0.0.108 → 0.0.110

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

@@ -2,6 +2,7 @@ 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 { getAgentExecutionConfigValue, getAgentExecutionObject, getAgentExecutionString } from "./support/agent-execution-config.js";
 import { discoverSkillPaths } from "./support/discovery.js";
 import { compileAgentMemories, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, getRuntimeModelDefaults, 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. " +
@@ -11,9 +12,7 @@ function requireSkills(pathEntries, workspaceRoot) {
     return Array.from(new Set(discoverSkillPaths(pathEntries, workspaceRoot)));
 }
 function resolveInheritancePolicy(agent) {
-    const langchainPolicy = typeof agent.langchainAgentConfig?.skillInheritancePolicy === "string" ? agent.langchainAgentConfig.skillInheritancePolicy : undefined;
-    const deepagentPolicy = typeof agent.deepAgentConfig?.skillInheritancePolicy === "string" ? agent.deepAgentConfig.skillInheritancePolicy : undefined;
-    return (langchainPolicy ?? deepagentPolicy ?? "default").trim();
+    return getAgentExecutionString(agent, "skillInheritancePolicy") ?? "default";
 }
 export function compileAgentSkills(workspaceRoot, agent, parentSkills = []) {
     const policyName = resolveInheritancePolicy(agent);
@@ -106,40 +105,28 @@ function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parent
         passthrough: execution.passthrough,
     };
 }
-function resolveDirectPrompt(agent) {
-    return resolvePromptValue(agent.langchainAgentConfig?.systemPrompt);
-}
 function resolveSystemPrompt(agent) {
+    const prompt = resolvePromptValue(getAgentExecutionConfigValue(agent, "systemPrompt"));
     if (agent.executionMode !== "deepagent") {
-        return resolveDirectPrompt(agent);
+        return prompt;
     }
-    const deepagentPrompt = resolvePromptValue(agent.deepAgentConfig?.systemPrompt);
-    return [deepagentPrompt ?? resolveDirectPrompt(agent), WORKSPACE_BOUNDARY_GUIDANCE].filter(Boolean).join("\n\n");
+    return [prompt, WORKSPACE_BOUNDARY_GUIDANCE].filter(Boolean).join("\n\n");
 }
 function resolveInterruptOn(agent) {
-    if (agent.executionMode !== "deepagent") {
-        return undefined;
-    }
-    return (agent.deepAgentConfig?.interruptOn ??
-        agent.langchainAgentConfig?.interruptOn);
+    return getAgentExecutionObject(agent, "interruptOn");
 }
 function resolveResponseFormat(agent) {
-    return agent.deepAgentConfig?.responseFormat ?? agent.langchainAgentConfig?.responseFormat;
+    return getAgentExecutionConfigValue(agent, "responseFormat");
 }
 function resolveContextSchema(agent) {
-    return agent.deepAgentConfig?.contextSchema ?? agent.langchainAgentConfig?.contextSchema;
+    return getAgentExecutionConfigValue(agent, "contextSchema");
 }
 function resolveCompiledMiddleware(agent, models) {
-    const middleware = agent.deepAgentConfig?.middleware ??
-        agent.langchainAgentConfig?.middleware;
+    const middleware = getAgentExecutionConfigValue(agent, "middleware");
     return compileMiddlewareConfigs(middleware, models, agent.id);
 }
 function resolvePassthrough(agent) {
-    const passthrough = typeof agent.deepAgentConfig?.passthrough === "object" && agent.deepAgentConfig.passthrough
-        ? agent.deepAgentConfig.passthrough
-        : typeof agent.langchainAgentConfig?.passthrough === "object" && agent.langchainAgentConfig.passthrough
-            ? agent.langchainAgentConfig.passthrough
-            : undefined;
+    const passthrough = getAgentExecutionObject(agent, "passthrough");
     return passthrough ? { ...passthrough } : undefined;
 }
 function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory) {
@@ -166,9 +153,7 @@ function resolveBackendConfig(agent, refs) {
     if (agent.executionMode !== "deepagent") {
         return undefined;
     }
-    const backendConfig = typeof agent.deepAgentConfig?.backend === "object" && agent.deepAgentConfig.backend
-        ? agent.deepAgentConfig.backend
-        : undefined;
+    const backendConfig = getAgentExecutionObject(agent, "backend");
     if (!backendConfig) {
         return undefined;
     }
@@ -221,11 +206,7 @@ function materializeWorkspaceObjectConfig(refs, ref, allowedKinds, ownerLabel) {
     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;
+    const inlineStore = getAgentExecutionObject(agent, "store");
     if (!inlineStore) {
         return undefined;
     }
@@ -237,15 +218,7 @@ function resolveStoreConfig(agent, refs) {
     return { config: inlineStore };
 }
 function resolveCheckpointerConfig(agent, refs) {
-    const inlineAgentCheckpointer = typeof agent.deepAgentConfig?.checkpointer === "object" && agent.deepAgentConfig.checkpointer
-        ? agent.deepAgentConfig.checkpointer
-        : typeof agent.deepAgentConfig?.checkpointer === "boolean"
-            ? agent.deepAgentConfig.checkpointer
-            : typeof agent.langchainAgentConfig?.checkpointer === "object" && agent.langchainAgentConfig.checkpointer
-                ? agent.langchainAgentConfig.checkpointer
-                : typeof agent.langchainAgentConfig?.checkpointer === "boolean"
-                    ? agent.langchainAgentConfig.checkpointer
-                    : undefined;
+    const inlineAgentCheckpointer = getAgentExecutionConfigValue(agent, "checkpointer");
     if (inlineAgentCheckpointer === undefined) {
         return undefined;
     }
@@ -260,11 +233,7 @@ function resolveCheckpointerConfig(agent, refs) {
     return { config: inlineAgentCheckpointer };
 }
 function resolveRuntimeMemoryConfig(agent, refs) {
-    const inlineRuntimeMemory = typeof agent.deepAgentConfig?.runtimeMemory === "object" && agent.deepAgentConfig.runtimeMemory
-        ? agent.deepAgentConfig.runtimeMemory
-        : typeof agent.langchainAgentConfig?.runtimeMemory === "object" && agent.langchainAgentConfig.runtimeMemory
-            ? agent.langchainAgentConfig.runtimeMemory
-            : undefined;
+    const inlineRuntimeMemory = getAgentExecutionObject(agent, "runtimeMemory");
     if (inlineRuntimeMemory) {
         if (isRefConfig(inlineRuntimeMemory)) {
             return {
@@ -276,34 +245,6 @@ function resolveRuntimeMemoryConfig(agent, refs) {
     const runtimeMemoryDefaults = getRuntimeMemoryDefaults(refs);
     return runtimeMemoryDefaults ? { config: runtimeMemoryDefaults } : undefined;
 }
-function resolveLangGraphWorkflowConfig(agent, refs) {
-    const workflowConfig = typeof agent.langchainAgentConfig?.workflow === "object" && agent.langchainAgentConfig.workflow
-        ? agent.langchainAgentConfig.workflow
-        : typeof agent.langchainAgentConfig?.langgraph === "object" && agent.langchainAgentConfig.langgraph
-            ? agent.langchainAgentConfig.langgraph
-            : typeof agent.langchainAgentConfig?.passthrough === "object" &&
-                agent.langchainAgentConfig.passthrough &&
-                typeof agent.langchainAgentConfig.passthrough.workflow === "object" &&
-                agent.langchainAgentConfig.passthrough.workflow
-                ? agent.langchainAgentConfig.passthrough.workflow
-                : typeof agent.langchainAgentConfig?.passthrough === "object" &&
-                    agent.langchainAgentConfig.passthrough &&
-                    typeof agent.langchainAgentConfig.passthrough.langgraph === "object" &&
-                    agent.langchainAgentConfig.passthrough.langgraph
-                    ? agent.langchainAgentConfig.passthrough.langgraph
-                    : undefined;
-    if (!workflowConfig) {
-        return undefined;
-    }
-    if (isRefConfig(workflowConfig)) {
-        return {
-            config: materializeWorkspaceObjectConfig(refs, workflowConfig.ref, [], `Agent ${agent.id} workflow`),
-        };
-    }
-    return {
-        config: workflowConfig,
-    };
-}
 function resolveRuntimeModelRefs(agent, refs) {
     const merged = {
         ...(getRuntimeModelDefaults(refs) ?? {}),
@@ -365,28 +306,25 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         },
     };
     if (agent.executionMode !== "deepagent") {
+        const langchainVersion = getAgentExecutionConfigValue(agent, "version", { executionMode: "langchain-v1" });
         const langchainAgentParams = {
             model: execution.model,
             tools: execution.tools,
             systemPrompt: execution.systemPrompt,
-            stateSchema: agent.langchainAgentConfig?.stateSchema,
+            stateSchema: getAgentExecutionConfigValue(agent, "stateSchema", { executionMode: "langchain-v1" }),
             responseFormat: execution.responseFormat,
             contextSchema: execution.contextSchema,
-            filesystem: typeof agent.langchainAgentConfig?.filesystem === "object" && agent.langchainAgentConfig.filesystem
-                ? { ...agent.langchainAgentConfig.filesystem }
-                : undefined,
+            filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
             middleware: execution.middleware,
             passthrough: execution.passthrough,
             subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory),
             memory: compiledAgentMemory,
             skills: compiledAgentSkills,
-            generalPurposeAgent: typeof agent.langchainAgentConfig?.generalPurposeAgent === "boolean" ? agent.langchainAgentConfig.generalPurposeAgent : undefined,
-            taskDescription: typeof agent.langchainAgentConfig?.taskDescription === "string" && agent.langchainAgentConfig.taskDescription.trim()
-                ? agent.langchainAgentConfig.taskDescription
-                : undefined,
-            includeAgentName: agent.langchainAgentConfig?.includeAgentName === "inline" ? "inline" : undefined,
-            version: agent.langchainAgentConfig?.version === "v1" || agent.langchainAgentConfig?.version === "v2"
-                ? agent.langchainAgentConfig.version
+            generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "langchain-v1" }),
+            taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "langchain-v1" }),
+            includeAgentName: getAgentExecutionConfigValue(agent, "includeAgentName", { executionMode: "langchain-v1" }) === "inline" ? "inline" : undefined,
+            version: langchainVersion === "v1" || langchainVersion === "v2"
+                ? langchainVersion
                 : undefined,
             name: resolveAgentRuntimeName(agent),
             description: agent.description,
@@ -418,10 +356,8 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         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,
+        generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "deepagent" }),
+        taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "deepagent" }),
     };
     return {
         ...base,

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

@@ -1,3 +1,4 @@
+import { getAgentExecutionString } from "./agent-execution-config.js";
 function normalizeCapabilities(capabilities) {
     return {
         delegation: capabilities?.delegation === true,
@@ -29,12 +30,7 @@ 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;
+    return getAgentExecutionString(agent, "systemPrompt");
 }
 export function hasAgentSystemPrompt(agent) {
     return typeof getAgentSystemPrompt(agent) === "string";

package/dist/workspace/support/agent-execution-config.d.ts

@@ -0,0 +1,18 @@
+import type { ExecutionMode } from "../../contracts/core.js";
+import type { ParsedAgentObject } from "../../contracts/types.js";
+type AgentExecutionConfig = Record<string, unknown>;
+export declare function getAgentExecutionConfigs(agent: ParsedAgentObject, executionMode?: ExecutionMode): AgentExecutionConfig[];
+export declare function getAgentExecutionConfigValue<T = unknown>(agent: ParsedAgentObject, key: string, options?: {
+    aliases?: string[];
+    executionMode?: ExecutionMode;
+}): T | undefined;
+export declare function getAgentExecutionObject(agent: ParsedAgentObject, key: string, options?: {
+    aliases?: string[];
+    executionMode?: ExecutionMode;
+}): AgentExecutionConfig | undefined;
+export declare function getAgentExecutionString(agent: ParsedAgentObject, key: string, options?: {
+    aliases?: string[];
+    executionMode?: ExecutionMode;
+    trim?: boolean;
+}): string | undefined;
+export {};

package/dist/workspace/support/agent-execution-config.js

@@ -0,0 +1,35 @@
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function getConfigsForMode(agent, executionMode = agent.executionMode) {
+    const primary = executionMode === "deepagent" ? asRecord(agent.deepAgentConfig) : asRecord(agent.langchainAgentConfig);
+    const fallback = executionMode === "deepagent" ? asRecord(agent.langchainAgentConfig) : asRecord(agent.deepAgentConfig);
+    return [primary, fallback].filter((config) => config !== undefined);
+}
+export function getAgentExecutionConfigs(agent, executionMode = agent.executionMode) {
+    return getConfigsForMode(agent, executionMode);
+}
+export function getAgentExecutionConfigValue(agent, key, options = {}) {
+    const keys = [key, ...(options.aliases ?? [])];
+    for (const config of getConfigsForMode(agent, options.executionMode)) {
+        for (const candidate of keys) {
+            const value = config[candidate];
+            if (value !== undefined) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+export function getAgentExecutionObject(agent, key, options = {}) {
+    return asRecord(getAgentExecutionConfigValue(agent, key, options));
+}
+export function getAgentExecutionString(agent, key, options = {}) {
+    const value = getAgentExecutionConfigValue(agent, key, options);
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    return options.trim === false ? value : value.trim() || undefined;
+}

package/dist/workspace/validate.js

@@ -1,10 +1,8 @@
 import { hasAgentSystemPrompt, isDelegationCapableAgent, isMemoryCapableAgent, } from "./support/agent-capabilities.js";
+import { getAgentExecutionConfigValue, getAgentExecutionConfigs } from "./support/agent-execution-config.js";
 const allowedExecutionModes = new Set(["deepagent", "langchain-v1"]);
 function validateCheckpointerConfig(agent) {
-    const checkpointer = (typeof agent.deepAgentConfig?.checkpointer === "object" && agent.deepAgentConfig.checkpointer) ||
-        (typeof agent.deepAgentConfig?.checkpointer === "boolean" ? agent.deepAgentConfig.checkpointer : undefined) ||
-        (typeof agent.langchainAgentConfig?.checkpointer === "boolean" ? agent.langchainAgentConfig.checkpointer : undefined) ||
-        (typeof agent.langchainAgentConfig?.checkpointer === "object" && agent.langchainAgentConfig.checkpointer);
+    const checkpointer = getAgentExecutionConfigValue(agent, "checkpointer");
     if (typeof checkpointer === "boolean") {
         return;
     }
@@ -19,10 +17,10 @@ function validateCheckpointerConfig(agent) {
     }
 }
 function validateMiddlewareConfig(agent) {
-    const middlewareConfigs = [
-        ...(agent.langchainAgentConfig?.middleware ?? []),
-        ...(agent.deepAgentConfig?.middleware ?? []),
-    ];
+    const middlewareConfigs = getAgentExecutionConfigs(agent).flatMap((config) => {
+        const middleware = config.middleware;
+        return Array.isArray(middleware) ? middleware : [];
+    });
     for (const config of middlewareConfigs) {
         if (typeof config !== "object" || config === null || Array.isArray(config)) {
             throw new Error(`Agent ${agent.id} middleware entries must be objects`);
@@ -59,9 +57,6 @@ export function validateAgent(agent) {
     if (!agent.description.trim()) {
         throw new Error(`Agent ${agent.id} description must not be empty`);
     }
-    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 (!isMemoryCapableAgent(agent) && agent.memorySources.length > 0) {
         throw new Error(`Agent ${agent.id} cannot define memory unless it uses a memory-capable backend`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.108",
+  "version": "0.0.110",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/dist/runtime/adapter/deepagent-runnable-config.d.ts

@@ -1,13 +0,0 @@
-import type { DeepAgentParams } from "../../contracts/types.js";
-export declare function buildDeepAgentRunnableConfig(params: {
-    compatibleParams: DeepAgentParams;
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedSubagents: unknown[];
-    resolvedCheckpointer: unknown;
-    resolvedStore: unknown;
-    resolvedBackend: unknown;
-    resolvedInterruptOn: unknown;
-    resolvedSkills: string[];
-}): Record<string, unknown>;

package/dist/runtime/adapter/deepagent-runnable-config.js

@@ -1,29 +0,0 @@
-import { buildResolvedRunnableConfig } from "./runnable-config.js";
-export function buildDeepAgentRunnableConfig(params) {
-    const { compatibleParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedSubagents, resolvedCheckpointer, resolvedStore, resolvedBackend, resolvedInterruptOn, resolvedSkills, } = params;
-    return buildResolvedRunnableConfig({
-        passthrough: compatibleParams.passthrough ?? {},
-        staticConfig: {
-            systemPrompt: compatibleParams.systemPrompt,
-            responseFormat: compatibleParams.responseFormat,
-            contextSchema: compatibleParams.contextSchema,
-            name: compatibleParams.name,
-            memory: compatibleParams.memory,
-            skills: resolvedSkills,
-            generalPurposeAgent: compatibleParams.generalPurposeAgent,
-            taskDescription: compatibleParams.taskDescription,
-        },
-        resolved: {
-            resolvedModel: resolvedModel,
-            resolvedTools: resolvedTools,
-            resolvedMiddleware: resolvedMiddleware,
-            resolvedCheckpointer: resolvedCheckpointer,
-            resolvedStore: resolvedStore,
-        },
-        extraConfig: {
-            subagents: resolvedSubagents,
-            backend: resolvedBackend,
-            interruptOn: resolvedInterruptOn,
-        },
-    });
-}

package/dist/runtime/adapter/langchain-runnable-config.d.ts

@@ -1,11 +0,0 @@
-import type { LangChainAgentParams } from "../../contracts/types.js";
-export declare function buildLangChainRunnableConfig(params: {
-    langchainParams: LangChainAgentParams;
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedCheckpointer: unknown;
-    resolvedStore: unknown;
-    passthroughOverride?: Record<string, unknown>;
-    systemPromptOverride?: string;
-}): Record<string, unknown>;

package/dist/runtime/adapter/langchain-runnable-config.js

@@ -1,24 +0,0 @@
-import { buildResolvedRunnableConfig } from "./runnable-config.js";
-export function buildLangChainRunnableConfig(params) {
-    const { langchainParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedCheckpointer, resolvedStore, passthroughOverride, systemPromptOverride, } = params;
-    return buildResolvedRunnableConfig({
-        passthrough: (passthroughOverride ?? langchainParams.passthrough ?? {}),
-        staticConfig: {
-            systemPrompt: systemPromptOverride ?? langchainParams.systemPrompt,
-            stateSchema: langchainParams.stateSchema,
-            responseFormat: langchainParams.responseFormat,
-            contextSchema: langchainParams.contextSchema,
-            includeAgentName: langchainParams.includeAgentName,
-            version: langchainParams.version,
-            name: langchainParams.name,
-            description: langchainParams.description,
-        },
-        resolved: {
-            resolvedModel: resolvedModel,
-            resolvedTools: resolvedTools,
-            resolvedMiddleware: resolvedMiddleware,
-            resolvedCheckpointer: resolvedCheckpointer,
-            resolvedStore: resolvedStore,
-        },
-    });
-}