@botbotgo/agent-harness 0.0.118 → 0.0.119

package/dist/contracts/workspace.d.ts

@@ -193,8 +193,21 @@ export type CompiledAgentBinding = {
         kind: string;
         config?: Record<string, unknown>;
     };
+    /**
+     * Canonical execution binding compiled from workspace YAML.
+     * Runtime code should prefer this field and treat backend-specific aliases
+     * below as compatibility shims.
+     */
     execution?: CompiledExecutionBinding;
+    /**
+     * Compatibility alias for older tests and callers.
+     * Prefer `execution.kind === "langchain-v1"` and `execution.params`.
+     */
     langchainAgentParams?: LangChainAgentParams;
+    /**
+     * Compatibility alias for older tests and callers.
+     * Prefer `execution.kind === "deepagent"` and `execution.params`.
+     */
     deepAgentParams?: DeepAgentParams;
     harnessRuntime: {
         runRoot: string;

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.117";
+export declare const AGENT_HARNESS_VERSION = "0.0.118";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.117";
+export const AGENT_HARNESS_VERSION = "0.0.118";

package/dist/runtime/harness/run/routing.d.ts

@@ -1,12 +1,14 @@
 import { type MessageContent, type ThreadSummary, type WorkspaceBundle } from "../../../contracts/types.js";
 import type { RoutingRule } from "../../../workspace/support/workspace-ref-utils.js";
 export declare function getDefaultHostAgentId(workspace: WorkspaceBundle, preferredHostAgentId?: string): string;
+export declare function getDefaultRuntimeEntryAgentId(workspace: WorkspaceBundle, preferredRuntimeEntryAgentId?: string): string;
 export declare function resolveSelectedAgentId(options: {
     workspace: WorkspaceBundle;
     input: MessageContent;
     requestedAgentId?: string;
     threadId?: string;
     preferredHostAgentId?: string;
+    preferredRuntimeEntryAgentId?: string;
     getThreadSummary: (threadId: string) => Promise<ThreadSummary | null>;
 }): Promise<string>;
 export declare function routeAgentId(options: {

package/dist/runtime/harness/run/routing.js

@@ -10,8 +10,12 @@ export function getDefaultHostAgentId(workspace, preferredHostAgentId) {
     }
     return inferRoutingBindings(workspace).primaryBinding?.agent.id ?? "agent";
 }
+export function getDefaultRuntimeEntryAgentId(workspace, preferredRuntimeEntryAgentId) {
+    return getDefaultHostAgentId(workspace, preferredRuntimeEntryAgentId);
+}
 export async function resolveSelectedAgentId(options) {
-    const { workspace, input, requestedAgentId, threadId, preferredHostAgentId, getThreadSummary } = options;
+    const { workspace, input, requestedAgentId, threadId, preferredHostAgentId, preferredRuntimeEntryAgentId, getThreadSummary, } = options;
+    const preferredEntryAgentId = preferredRuntimeEntryAgentId ?? preferredHostAgentId;
     if (!requestedAgentId || requestedAgentId === AUTO_AGENT_ID) {
         if (threadId) {
             const thread = await getThreadSummary(threadId);
@@ -20,7 +24,7 @@ export async function resolveSelectedAgentId(options) {
                 return thread.agentId;
             }
         }
-        return getDefaultHostAgentId(workspace, preferredHostAgentId);
+        return getDefaultRuntimeEntryAgentId(workspace, preferredEntryAgentId);
     }
     return requestedAgentId;
 }
@@ -40,5 +44,5 @@ export function routeAgentId(options) {
     if (defaultBinding) {
         return defaultBinding.agent.id;
     }
-    return getDefaultHostAgentId(workspace, routingDefaultAgentId);
+    return getDefaultRuntimeEntryAgentId(workspace, routingDefaultAgentId);
 }

package/dist/runtime/harness/run/start-run.js

@@ -3,7 +3,7 @@ import { createPersistentId } from "../../../utils/id.js";
 import { normalizeMessageContent } from "../../../utils/message-content.js";
 import { buildPersistedRunRequest, normalizeRunPriority } from "./helpers.js";
 import { getRequiredWorkspaceBinding } from "../bindings.js";
-import { getBindingAdapterKind } from "../../support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingRuntimeExecutionMode } from "../../support/compiled-binding.js";
 export async function ensureThreadStarted(runtime, input) {
     const { selectedAgentId, binding, message, runRequest, existingThreadId } = input;
     const threadId = existingThreadId ?? createPersistentId();
@@ -23,7 +23,7 @@ export async function ensureThreadStarted(runtime, input) {
             runId,
             status: "running",
             createdAt,
-            executionMode: getBindingAdapterKind(binding),
+            executionMode: getBindingRuntimeExecutionMode(binding),
             adapterKind: getBindingAdapterKind(binding),
             userMessage,
             runRequest,
@@ -46,7 +46,7 @@ export async function ensureThreadStarted(runtime, input) {
                 threadId,
                 runId,
                 agentId: binding.agent.id,
-                executionMode: getBindingAdapterKind(binding),
+                executionMode: getBindingRuntimeExecutionMode(binding),
                 adapterKind: getBindingAdapterKind(binding),
                 createdAt,
             }),

package/dist/runtime/harness.d.ts

@@ -14,8 +14,8 @@ export declare class AgentHarnessRuntime {
     private readonly stores;
     private readonly embeddingModels;
     private readonly vectorStores;
-    private readonly hostBindings;
-    private readonly defaultHostBinding?;
+    private readonly runtimeEntryBindings;
+    private readonly defaultRuntimeEntryBinding?;
     private readonly defaultRunRootValue;
     private readonly defaultStore;
     private readonly runtimeMemoryStore;
@@ -38,7 +38,7 @@ export declare class AgentHarnessRuntime {
     private readonly backgroundEventRuntime;
     private readonly runtimeEventOperations;
     private defaultRunRoot;
-    private getDefaultHostAgentId;
+    private getDefaultRuntimeEntryAgentId;
     private resolveSelectedAgentId;
     private createPrepareRunStartRuntime;
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);

package/dist/runtime/harness.js

@@ -18,10 +18,10 @@ import { buildResumePayload as buildHarnessResumePayload, resolveApprovalRecord
 import { cancelRunOperation, executeQueuedRunOperation, resumeRun } from "./harness/run/run-operations.js";
 import { acquireRunSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-acquisition.js";
 import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-queue.js";
-import { getDefaultHostAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
+import { getDefaultRuntimeEntryAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
 import { resolveStoreFromConfig, } from "./harness/run/resources.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
-import { getBindingAdapterKind } from "./support/compiled-binding.js";
+import { getBindingRuntimeExecutionMode, } from "./support/compiled-binding.js";
 import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
@@ -48,8 +48,8 @@ export class AgentHarnessRuntime {
     stores = new Map();
     embeddingModels = new Map();
     vectorStores = new Map();
-    hostBindings;
-    defaultHostBinding;
+    runtimeEntryBindings;
+    defaultRuntimeEntryBinding;
     defaultRunRootValue;
     defaultStore;
     runtimeMemoryStore;
@@ -74,8 +74,8 @@ export class AgentHarnessRuntime {
     defaultRunRoot() {
         return this.defaultRunRootValue;
     }
-    getDefaultHostAgentId() {
-        return getDefaultHostAgentId(this.workspace, this.routingDefaultAgentId);
+    getDefaultRuntimeEntryAgentId() {
+        return getDefaultRuntimeEntryAgentId(this.workspace, this.routingDefaultAgentId);
     }
     async resolveSelectedAgentId(input, requestedAgentId, threadId) {
         return resolveSelectedAgentId({
@@ -83,7 +83,7 @@ export class AgentHarnessRuntime {
             input,
             requestedAgentId,
             threadId,
-            preferredHostAgentId: this.routingDefaultAgentId,
+            preferredRuntimeEntryAgentId: this.routingDefaultAgentId,
             getThreadSummary: (currentThreadId) => this.getSession(currentThreadId),
         });
     }
@@ -100,16 +100,16 @@ export class AgentHarnessRuntime {
     constructor(workspace, runtimeAdapterOptions = {}) {
         this.workspace = workspace;
         this.runtimeAdapterOptions = runtimeAdapterOptions;
-        this.hostBindings = inferRoutingBindings(this.workspace).hostBindings;
-        this.defaultHostBinding = this.hostBindings[0];
-        this.defaultRunRootValue = this.defaultHostBinding?.harnessRuntime.runRoot ?? `${this.workspace.workspaceRoot}/run-data`;
+        this.runtimeEntryBindings = inferRoutingBindings(this.workspace).runtimeEntryBindings;
+        this.defaultRuntimeEntryBinding = this.runtimeEntryBindings[0];
+        this.defaultRunRootValue = this.defaultRuntimeEntryBinding?.harnessRuntime.runRoot ?? `${this.workspace.workspaceRoot}/run-data`;
         const runRoot = this.defaultRunRoot();
         this.persistence = new SqlitePersistence(runRoot);
-        const defaultStoreConfig = this.defaultHostBinding?.harnessRuntime.store;
+        const defaultStoreConfig = this.defaultRuntimeEntryBinding?.harnessRuntime.store;
         this.defaultStore = resolveStoreFromConfig(this.stores, defaultStoreConfig, runRoot) ?? new FileBackedStore(`${runRoot}/store.json`);
-        const runtimeMemoryStoreConfig = typeof this.defaultHostBinding?.harnessRuntime.runtimeMemory?.store === "object" &&
-            this.defaultHostBinding?.harnessRuntime.runtimeMemory?.store
-            ? this.defaultHostBinding.harnessRuntime.runtimeMemory.store
+        const runtimeMemoryStoreConfig = typeof this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory?.store === "object" &&
+            this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory?.store
+            ? this.defaultRuntimeEntryBinding.harnessRuntime.runtimeMemory.store
             : undefined;
         this.runtimeMemoryStore = resolveStoreFromConfig(this.stores, runtimeMemoryStoreConfig, runRoot) ?? this.defaultStore;
         this.resolvedRuntimeAdapterOptions = resolveRuntimeAdapterOptions({
@@ -438,7 +438,7 @@ export class AgentHarnessRuntime {
                 agentId: activeBinding.agent.id,
                 requestedAgentId: defaultRequestedAgentId(options.agentId),
                 selectedAgentId: activeSelectedAgentId,
-                executionMode: getBindingAdapterKind(activeBinding),
+                executionMode: getBindingRuntimeExecutionMode(activeBinding),
             }),
         });
         await runCreatedEventPromise;

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

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
 export type BindingExecutionView = {
     adapterKind: string;
     langchainParams?: LangChainAgentParams;
@@ -17,6 +17,8 @@ export type BindingExecutionView = {
 };
 export declare function getBindingExecutionView(binding: CompiledAgentBinding): BindingExecutionView;
 export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
+export declare function getBindingCanonicalExecution(binding: CompiledAgentBinding): CompiledExecutionBinding | undefined;
+export declare function getBindingRuntimeExecutionMode(binding: CompiledAgentBinding): string;
 export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LangChainAgentParams | undefined;
 export declare function getBindingDeepAgentParams(binding: CompiledAgentBinding): DeepAgentParams | undefined;
 export declare function getBindingExecutionParams(binding: CompiledAgentBinding): LangChainAgentParams | DeepAgentParams | undefined;

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

@@ -3,24 +3,80 @@ 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") {
+        binding.langchainAgentParams ??= binding.execution.params;
+        return { adapterKind, execution: binding.execution };
+    }
+    if (binding.execution?.kind === "deepagent") {
+        binding.deepAgentParams ??= binding.execution.params;
+        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;
+        return { adapterKind, execution };
+    }
+    if (binding.deepAgentParams) {
+        const execution = {
+            kind: "deepagent",
+            params: binding.deepAgentParams,
+        };
+        binding.execution = execution;
+        return { adapterKind, execution };
+    }
+    const legacyAdapterParams = getLegacyAdapterParams(binding);
+    if (adapterKind === "langchain-v1" && legacyAdapterParams) {
+        const params = legacyAdapterParams;
+        binding.langchainAgentParams = params;
+        binding.execution = {
+            kind: "langchain-v1",
+            params,
+        };
+        return { adapterKind, execution: binding.execution };
+    }
+    if (adapterKind === "deepagent" && legacyAdapterParams) {
+        const params = legacyAdapterParams;
+        binding.deepAgentParams = params;
+        binding.execution = {
+            kind: "deepagent",
+            params,
+        };
+        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" ? normalized.execution.params : undefined;
+    const deepAgentParams = 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 ?? [])
@@ -54,6 +110,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 +126,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);
@@ -139,10 +192,10 @@ export function getBindingFilesystemConfig(binding) {
     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/workspace/agent-binding-compiler.js

@@ -247,11 +247,11 @@ 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 compiledAgentModel = executionCore.model;
     const backend = resolveBackendConfig(agent, refs);
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
@@ -275,61 +275,61 @@ 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,
+        const executionBinding = {
+            kind: "langchain-v1",
+            params: {
+                model: executionCore.model,
+                tools: executionCore.tools,
+                systemPrompt: executionCore.systemPrompt,
+                interruptOn: resolveInterruptOn(agent),
+                stateSchema: getAgentExecutionConfigValue(agent, "stateSchema", { executionMode: "langchain-v1" }),
+                responseFormat: executionCore.responseFormat,
+                contextSchema: executionCore.contextSchema,
+                filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
+                middleware: executionCore.middleware,
+                passthrough: executionCore.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,
-            },
-            langchainAgentParams,
+            execution: executionBinding,
+            langchainAgentParams: executionBinding.params,
         };
     }
-    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,
+    const executionBinding = {
+        kind: "deepagent",
+        params: {
+            model: executionCore.model,
+            tools: executionCore.tools,
+            systemPrompt: executionCore.systemPrompt,
+            responseFormat: executionCore.responseFormat,
+            contextSchema: executionCore.contextSchema,
+            middleware: executionCore.middleware,
+            passthrough: executionCore.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,
-        },
-        deepAgentParams,
+        execution: executionBinding,
+        deepAgentParams: executionBinding.params,
     };
 }

package/package.json

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