@botbotgo/agent-harness 0.0.118 → 0.0.120

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

@@ -1,31 +1,93 @@
+import { attachLegacyExecutionAliases, stripLegacyExecutionAliases } from "../../utils/compiled-binding.js";
 import { asRecord } from "../../utils/object.js";
 const bindingExecutionViewCache = new WeakMap();
 function getLegacyAdapterParams(binding) {
     return asRecord(binding.adapter?.config?.params);
 }
+function inferBindingAdapterKind(binding) {
+    if (binding.adapter?.kind) {
+        return binding.adapter.kind;
+    }
+    if (binding.execution?.kind === "langchain-v1" || binding.execution?.kind === "deepagent") {
+        return binding.execution.kind;
+    }
+    if (binding.langchainAgentParams) {
+        return "langchain-v1";
+    }
+    if (binding.deepAgentParams) {
+        return "deepagent";
+    }
+    return binding.agent.executionMode;
+}
+function normalizeBindingExecution(binding) {
+    const adapterKind = inferBindingAdapterKind(binding);
+    if (binding.execution?.kind === "langchain-v1") {
+        attachLegacyExecutionAliases(binding);
+        return { adapterKind, execution: binding.execution };
+    }
+    if (binding.execution?.kind === "deepagent") {
+        attachLegacyExecutionAliases(binding);
+        return { adapterKind, execution: binding.execution };
+    }
+    if (adapterKind !== "langchain-v1" && adapterKind !== "deepagent") {
+        return { adapterKind };
+    }
+    if (binding.langchainAgentParams) {
+        const execution = {
+            kind: "langchain-v1",
+            params: binding.langchainAgentParams,
+        };
+        binding.execution = execution;
+        attachLegacyExecutionAliases(binding);
+        return { adapterKind, execution };
+    }
+    if (binding.deepAgentParams) {
+        const execution = {
+            kind: "deepagent",
+            params: binding.deepAgentParams,
+        };
+        binding.execution = execution;
+        attachLegacyExecutionAliases(binding);
+        return { adapterKind, execution };
+    }
+    const legacyAdapterParams = getLegacyAdapterParams(binding);
+    if (adapterKind === "langchain-v1" && legacyAdapterParams) {
+        const params = legacyAdapterParams;
+        binding.execution = {
+            kind: "langchain-v1",
+            params,
+        };
+        attachLegacyExecutionAliases(binding);
+        return { adapterKind, execution: binding.execution };
+    }
+    if (adapterKind === "deepagent" && legacyAdapterParams) {
+        const params = legacyAdapterParams;
+        binding.execution = {
+            kind: "deepagent",
+            params,
+        };
+        attachLegacyExecutionAliases(binding);
+        return { adapterKind, execution: binding.execution };
+    }
+    return { adapterKind };
+}
 function deriveBindingExecutionView(binding) {
     const cached = bindingExecutionViewCache.get(binding);
     if (cached) {
         return cached;
     }
-    const adapterKind = binding.adapter?.kind ?? binding.agent.executionMode;
-    const legacyAdapterParams = getLegacyAdapterParams(binding);
-    const compiledExecution = binding.execution;
-    const langchainParams = (compiledExecution?.kind === "langchain-v1" ? compiledExecution.params : undefined) ??
-        binding.langchainAgentParams ??
-        (adapterKind === "langchain-v1" && legacyAdapterParams
-            ? legacyAdapterParams
-            : undefined);
-    const deepAgentParams = (compiledExecution?.kind === "deepagent" ? compiledExecution.params : undefined) ??
-        binding.deepAgentParams ??
-        (adapterKind === "deepagent" && legacyAdapterParams
-            ? legacyAdapterParams
-            : undefined);
+    const normalized = normalizeBindingExecution(binding);
+    const adapterKind = normalized.adapterKind;
+    const langchainParams = normalized.execution?.kind === "langchain-v1" ? binding.langchainAgentParams : undefined;
+    const deepAgentParams = normalized.execution?.kind === "deepagent" ? binding.deepAgentParams : undefined;
+    const canonicalLangchainParams = normalized.execution?.kind === "langchain-v1" ? normalized.execution.params : undefined;
+    const canonicalDeepAgentParams = normalized.execution?.kind === "deepagent" ? normalized.execution.params : undefined;
     const primaryTools = langchainParams?.tools ?? deepAgentParams?.tools ?? [];
     const middlewareConfigs = langchainParams?.middleware ?? deepAgentParams?.middleware;
     const middlewareKinds = new Set((middlewareConfigs ?? [])
         .map((entry) => typeof entry.kind === "string" ? entry.kind : "")
         .filter(Boolean));
+    const langchainRuntimeConfig = binding.harnessRuntime?.langchain;
     const view = {
         adapterKind,
         langchainParams,
@@ -37,13 +99,14 @@ function deriveBindingExecutionView(binding) {
         systemPrompt: langchainParams?.systemPrompt ?? deepAgentParams?.systemPrompt,
         middlewareConfigs,
         middlewareKinds,
-        interruptCompatibilityRules: langchainParams?.interruptOn ??
+        interruptCompatibilityRules: langchainRuntimeConfig?.interruptOn ??
+            langchainParams?.interruptOn ??
             deepAgentParams?.interruptOn,
-        storeConfig: deepAgentParams?.store ?? binding.harnessRuntime?.store,
-        langChainSubagentSupport: (langchainParams?.subagents?.length ?? 0) > 0 ||
-            langchainParams?.generalPurposeAgent === true ||
-            Boolean(langchainParams?.taskDescription?.trim()),
-        deepAgentSubagentCount: deepAgentParams?.subagents?.length ?? 0,
+        storeConfig: canonicalDeepAgentParams?.store ?? binding.harnessRuntime?.store,
+        langChainSubagentSupport: (langchainRuntimeConfig?.subagents?.length ?? 0) > 0 ||
+            (langchainRuntimeConfig?.generalPurposeAgent ?? langchainParams?.generalPurposeAgent) === true ||
+            Boolean((langchainRuntimeConfig?.taskDescription ?? langchainParams?.taskDescription)?.trim()),
+        deepAgentSubagentCount: canonicalDeepAgentParams?.subagents?.length ?? 0,
     };
     bindingExecutionViewCache.set(binding, view);
     return view;
@@ -54,6 +117,12 @@ export function getBindingExecutionView(binding) {
 export function getBindingAdapterKind(binding) {
     return getBindingExecutionView(binding).adapterKind;
 }
+export function getBindingCanonicalExecution(binding) {
+    return normalizeBindingExecution(binding).execution;
+}
+export function getBindingRuntimeExecutionMode(binding) {
+    return getBindingExecutionKind(binding) ?? getBindingAdapterKind(binding);
+}
 export function getBindingLangChainParams(binding) {
     return getBindingExecutionView(binding).langchainParams;
 }
@@ -64,17 +133,8 @@ export function getBindingExecutionParams(binding) {
     return getBindingExecutionView(binding).executionParams;
 }
 export function getBindingExecutionKind(binding) {
-    const execution = binding.execution;
-    if (execution?.kind === "langchain-v1" || execution?.kind === "deepagent") {
-        return execution.kind;
-    }
-    if (getBindingAdapterKind(binding) === "langchain-v1" || binding.langchainAgentParams) {
-        return "langchain-v1";
-    }
-    if (getBindingAdapterKind(binding) === "deepagent" || binding.deepAgentParams) {
-        return "deepagent";
-    }
-    return undefined;
+    const execution = getBindingCanonicalExecution(binding);
+    return execution?.kind;
 }
 export function withUpdatedBindingExecutionParams(binding, updater) {
     const kind = getBindingExecutionKind(binding);
@@ -84,48 +144,78 @@ export function withUpdatedBindingExecutionParams(binding, updater) {
     }
     const updatedParams = updater(params);
     if (kind === "langchain-v1") {
-        return {
-            ...binding,
+        return attachLegacyExecutionAliases({
+            ...stripLegacyExecutionAliases(binding),
             execution: {
                 kind,
                 params: updatedParams,
             },
-            langchainAgentParams: updatedParams,
-        };
+        });
     }
-    return {
-        ...binding,
+    return attachLegacyExecutionAliases({
+        ...stripLegacyExecutionAliases(binding),
         execution: {
             kind,
             params: updatedParams,
         },
-        deepAgentParams: updatedParams,
-    };
+    });
 }
 export function getBindingSkills(binding) {
+    const langchainSkills = binding.harnessRuntime?.langchain?.skills;
+    if (Array.isArray(langchainSkills)) {
+        return langchainSkills;
+    }
+    const legacyLangchainSkills = binding.langchainAgentParams?.skills;
+    if (Array.isArray(legacyLangchainSkills)) {
+        return legacyLangchainSkills;
+    }
     const execution = getBindingExecutionParams(binding);
-    return Array.isArray(execution?.skills) ? execution.skills : [];
+    return Array.isArray(execution?.skills)
+        ? (execution.skills)
+        : [];
 }
 export function getBindingMemorySources(binding) {
+    const langchainMemory = binding.harnessRuntime?.langchain?.memory;
+    if (Array.isArray(langchainMemory)) {
+        return langchainMemory;
+    }
+    const legacyLangchainMemory = binding.langchainAgentParams?.memory;
+    if (Array.isArray(legacyLangchainMemory)) {
+        return legacyLangchainMemory;
+    }
     const execution = getBindingExecutionParams(binding);
     return Array.isArray(execution?.memory)
         ? (execution.memory)
         : [];
 }
 export function getBindingSubagents(binding) {
+    const langchainSubagents = binding.harnessRuntime?.langchain?.subagents;
+    if (Array.isArray(langchainSubagents)) {
+        return langchainSubagents;
+    }
+    const legacyLangchainSubagents = binding.langchainAgentParams?.subagents;
+    if (Array.isArray(legacyLangchainSubagents)) {
+        return legacyLangchainSubagents;
+    }
     const execution = getBindingExecutionParams(binding);
     return Array.isArray(execution?.subagents)
         ? (execution.subagents)
         : [];
 }
 export function getBindingGeneralPurposeAgent(binding) {
-    const execution = getBindingExecutionParams(binding);
-    const value = execution?.generalPurposeAgent;
+    const langchainGeneralPurposeAgent = binding.harnessRuntime?.langchain?.generalPurposeAgent;
+    if (typeof langchainGeneralPurposeAgent === "boolean") {
+        return langchainGeneralPurposeAgent;
+    }
+    const value = binding.langchainAgentParams?.generalPurposeAgent;
     return typeof value === "boolean" ? value : undefined;
 }
 export function getBindingTaskDescription(binding) {
-    const execution = getBindingExecutionParams(binding);
-    const value = execution?.taskDescription;
+    const langchainTaskDescription = binding.harnessRuntime?.langchain?.taskDescription;
+    if (typeof langchainTaskDescription === "string" && langchainTaskDescription.trim().length > 0) {
+        return langchainTaskDescription;
+    }
+    const value = binding.langchainAgentParams?.taskDescription;
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 export function getBindingBackendConfig(binding) {
@@ -134,15 +224,18 @@ export function getBindingBackendConfig(binding) {
     return typeof backend === "object" && backend ? backend : undefined;
 }
 export function getBindingFilesystemConfig(binding) {
-    const execution = getBindingExecutionParams(binding);
-    const filesystem = execution?.filesystem;
+    const langchainFilesystem = binding.harnessRuntime?.langchain?.filesystem;
+    if (typeof langchainFilesystem === "object" && langchainFilesystem) {
+        return langchainFilesystem;
+    }
+    const filesystem = binding.langchainAgentParams?.filesystem;
     return typeof filesystem === "object" && filesystem ? filesystem : undefined;
 }
 export function isLangChainBinding(binding) {
-    return getBindingAdapterKind(binding) === "langchain-v1" || binding.execution?.kind === "langchain-v1" || Boolean(binding.langchainAgentParams);
+    return getBindingExecutionKind(binding) === "langchain-v1";
 }
 export function isDeepAgentBinding(binding) {
-    return getBindingAdapterKind(binding) === "deepagent" || binding.execution?.kind === "deepagent" || Boolean(binding.deepAgentParams);
+    return getBindingExecutionKind(binding) === "deepagent";
 }
 export function getBindingPrimaryTools(binding) {
     return getBindingExecutionView(binding).primaryTools;

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

@@ -11,5 +11,5 @@ export declare function createHarnessEvent(threadId: string, runId: string, sequ
 export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): InternalApprovalRecord;
 export declare function inferRoutingBindings(workspace: WorkspaceBundle): {
     primaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding;
-    hostBindings: import("../../contracts/workspace.js").CompiledAgentBinding[];
+    runtimeEntryBindings: import("../../contracts/workspace.js").CompiledAgentBinding[];
 };

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

@@ -87,9 +87,9 @@ export function createPendingApproval(threadId, runId, checkpointRef, input, int
     };
 }
 export function inferRoutingBindings(workspace) {
-    const hostBindings = Array.from(workspace.bindings.values());
-    const orchestrationHosts = hostBindings.filter((binding) => isDeepAgentBinding(binding));
-    const routingHosts = orchestrationHosts.length > 0 ? orchestrationHosts : hostBindings;
-    const primaryBinding = routingHosts.find((binding) => isDelegationCapableBinding(binding)) ?? routingHosts[0] ?? hostBindings[0];
-    return { primaryBinding, hostBindings };
+    const runtimeEntryBindings = Array.from(workspace.bindings.values());
+    const orchestrationRuntimeEntries = runtimeEntryBindings.filter((binding) => isDeepAgentBinding(binding));
+    const routingEntries = orchestrationRuntimeEntries.length > 0 ? orchestrationRuntimeEntries : runtimeEntryBindings;
+    const primaryBinding = routingEntries.find((binding) => isDelegationCapableBinding(binding)) ?? routingEntries[0] ?? runtimeEntryBindings[0];
+    return { primaryBinding, runtimeEntryBindings };
 }

package/dist/utils/compiled-binding.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledAgentBinding } from "../contracts/types.js";
+export declare function attachLegacyExecutionAliases(binding: CompiledAgentBinding): CompiledAgentBinding;
+export declare function stripLegacyExecutionAliases(binding: CompiledAgentBinding): CompiledAgentBinding;

package/dist/utils/compiled-binding.js

@@ -0,0 +1,33 @@
+function defineExecutionAlias(binding, property, kind) {
+    if (Object.prototype.hasOwnProperty.call(binding, property)) {
+        return;
+    }
+    Object.defineProperty(binding, property, {
+        configurable: true,
+        enumerable: false,
+        get() {
+            return binding.execution?.kind === kind ? binding.execution.params : undefined;
+        },
+        set(value) {
+            if (value === undefined) {
+                if (binding.execution?.kind === kind) {
+                    delete binding.execution;
+                }
+                return;
+            }
+            binding.execution = {
+                kind,
+                params: value,
+            };
+        },
+    });
+}
+export function attachLegacyExecutionAliases(binding) {
+    defineExecutionAlias(binding, "langchainAgentParams", "langchain-v1");
+    defineExecutionAlias(binding, "deepAgentParams", "deepagent");
+    return binding;
+}
+export function stripLegacyExecutionAliases(binding) {
+    const { langchainAgentParams: _langchainAgentParams, deepAgentParams: _deepAgentParams, ...rest } = binding;
+    return rest;
+}

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

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { getSkillInheritancePolicy, resolveToolTargets } from "../extensions.js";
+import { attachLegacyExecutionAliases } from "../utils/compiled-binding.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";
@@ -142,7 +143,6 @@ function compileExecutionCore(agent, models, tools) {
         responseFormat: resolveResponseFormat(agent),
         contextSchema: resolveContextSchema(agent),
         middleware: resolveCompiledMiddleware(agent, models),
-        passthrough: resolvePassthrough(agent),
     };
 }
 function resolveBackendConfig(agent, refs) {
@@ -247,11 +247,12 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const resilience = getResilienceConfig(refs);
     const compiledAgentSkills = compileAgentSkills(workspaceRoot, agent);
     const compiledAgentMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
-    const execution = compileExecutionCore({
+    const executionCore = compileExecutionCore({
         ...agent,
         modelRef: agent.modelRef || (internalSubagent ? "model/default" : ""),
     }, models, tools);
-    const compiledAgentModel = execution.model;
+    const passthrough = resolvePassthrough(agent);
+    const compiledAgentModel = executionCore.model;
     const backend = resolveBackendConfig(agent, refs);
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
@@ -268,6 +269,28 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             workspaceRoot,
             capabilities: inferAgentCapabilities(agent),
             resilience,
+            ...(agent.executionMode === "deepagent"
+                ? {
+                    deepagent: {
+                        description: agent.description,
+                        passthrough,
+                    },
+                }
+                : {}),
+            ...(agent.executionMode === "langchain-v1"
+                ? {
+                    langchain: {
+                        passthrough,
+                        interruptOn: resolveInterruptOn(agent),
+                        filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
+                        subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
+                        memory: compiledAgentMemory,
+                        skills: compiledAgentSkills,
+                        generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "langchain-v1" }),
+                        taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "langchain-v1" }),
+                    },
+                }
+                : {}),
             ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
             ...(store ? { store: store.config } : {}),
             ...(runtimeMemory ? { runtimeMemory: runtimeMemory.config } : {}),
@@ -275,61 +298,49 @@ 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,
-            interruptOn: resolveInterruptOn(agent),
-            stateSchema: getAgentExecutionConfigValue(agent, "stateSchema", { executionMode: "langchain-v1" }),
-            responseFormat: execution.responseFormat,
-            contextSchema: execution.contextSchema,
-            filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
-            middleware: execution.middleware,
-            passthrough: execution.passthrough,
-            subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
-            memory: compiledAgentMemory,
-            skills: compiledAgentSkills,
-            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,
-        };
-        return {
-            ...base,
-            execution: {
-                kind: "langchain-v1",
-                params: langchainAgentParams,
+        const executionBinding = {
+            kind: "langchain-v1",
+            params: {
+                model: executionCore.model,
+                tools: executionCore.tools,
+                systemPrompt: executionCore.systemPrompt,
+                stateSchema: getAgentExecutionConfigValue(agent, "stateSchema", { executionMode: "langchain-v1" }),
+                responseFormat: executionCore.responseFormat,
+                contextSchema: executionCore.contextSchema,
+                middleware: executionCore.middleware,
+                includeAgentName: getAgentExecutionConfigValue(agent, "includeAgentName", { executionMode: "langchain-v1" }) === "inline" ? "inline" : undefined,
+                version: langchainVersion === "v1" || langchainVersion === "v2"
+                    ? langchainVersion
+                    : undefined,
+                name: resolveAgentRuntimeName(agent),
+                description: agent.description,
             },
-            langchainAgentParams,
         };
+        return attachLegacyExecutionAliases({
+            ...base,
+            execution: executionBinding,
+        });
     }
-    const deepAgentParams = {
-        model: execution.model,
-        tools: execution.tools,
-        systemPrompt: execution.systemPrompt,
-        responseFormat: execution.responseFormat,
-        contextSchema: execution.contextSchema,
-        middleware: execution.middleware,
-        passthrough: execution.passthrough,
-        description: agent.description,
-        subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
-        interruptOn: resolveInterruptOn(agent),
-        ...(backend ? { backend: backend.config } : {}),
-        ...(store ? { store: store.config } : {}),
-        name: resolveAgentRuntimeName(agent),
-        memory: compiledAgentMemory,
-        skills: compiledAgentSkills,
-    };
-    return {
-        ...base,
-        execution: {
-            kind: "deepagent",
-            params: deepAgentParams,
+    const executionBinding = {
+        kind: "deepagent",
+        params: {
+            model: executionCore.model,
+            tools: executionCore.tools,
+            systemPrompt: executionCore.systemPrompt,
+            responseFormat: executionCore.responseFormat,
+            contextSchema: executionCore.contextSchema,
+            middleware: executionCore.middleware,
+            subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
+            interruptOn: resolveInterruptOn(agent),
+            ...(backend ? { backend: backend.config } : {}),
+            ...(store ? { store: store.config } : {}),
+            name: resolveAgentRuntimeName(agent),
+            memory: compiledAgentMemory,
+            skills: compiledAgentSkills,
         },
-        deepAgentParams,
     };
+    return attachLegacyExecutionAliases({
+        ...base,
+        execution: executionBinding,
+    });
 }

package/package.json

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