@botbotgo/agent-harness 0.0.117 → 0.0.119

package/dist/contracts/workspace.d.ts

@@ -180,13 +180,34 @@ export type DeepAgentParams = {
     memory: string[];
     skills: string[];
 };
+export type CompiledExecutionBinding = {
+    kind: "langchain-v1";
+    params: LangChainAgentParams;
+} | {
+    kind: "deepagent";
+    params: DeepAgentParams;
+};
 export type CompiledAgentBinding = {
     agent: ParsedAgentObject;
     adapter?: {
         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.116";
+export declare const AGENT_HARNESS_VERSION = "0.0.118";

package/dist/package-version.js

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

package/dist/resource/resource-impl.js

@@ -5,6 +5,7 @@ import { stat } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { CompositeBackend, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
+import { getBindingBackendConfig } from "../runtime/support/compiled-binding.js";
 import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
 import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
 import { createMcpToolResolver, } from "./mcp-tool-support.js";
@@ -175,7 +176,7 @@ function createInlineBackendInstance(workspaceRoot, kind, config, runtimeLike) {
 }
 function createInlineBackendResolver(workspace) {
     return (binding) => {
-        const backendConfig = binding.deepAgentParams?.backend;
+        const backendConfig = getBindingBackendConfig(binding);
         if (!backendConfig || typeof backendConfig !== "object") {
             return undefined;
         }

package/dist/runtime/adapter/flow/execution-context.js

@@ -1,5 +1,5 @@
 import { buildExecutableToolMap } from "../tool-resolution.js";
-import { getBindingLangChainParams, getBindingPrimaryModel, getBindingPrimaryTools, isLangChainBinding } from "../../support/compiled-binding.js";
+import { getBindingPrimaryModel, getBindingPrimaryTools, isLangChainBinding } from "../../support/compiled-binding.js";
 export function buildBindingToolCatalog(input) {
     const primaryTools = getBindingPrimaryTools(input.binding);
     const toolNameMapping = input.getToolNameMapping(input.binding);
@@ -31,11 +31,10 @@ export async function resolveLangChainStreamContext(input) {
     const forceInvokeFallback = isLangChainBinding(input.binding) &&
         primaryTools.length > 0 &&
         primaryModel?.provider === "openai-compatible";
-    const langchainParams = isLangChainBinding(input.binding) ? getBindingLangChainParams(input.binding) : undefined;
-    const resolvedLangChainModel = langchainParams
-        ? (await input.resolveModel(langchainParams.model))
+    const resolvedLangChainModel = primaryModel
+        ? (await input.resolveModel(primaryModel))
         : undefined;
-    const resolvedLangChainTools = langchainParams ? input.resolveTools(langchainParams.tools, input.binding) : [];
+    const resolvedLangChainTools = primaryTools.length > 0 ? input.resolveTools(primaryTools, input.binding) : [];
     const canUseDirectModelStream = !!resolvedLangChainModel &&
         (resolvedLangChainTools.length === 0 || typeof resolvedLangChainModel.bindTools !== "function");
     const langChainStreamModel = resolvedLangChainModel && canUseDirectModelStream

package/dist/runtime/adapter/middleware-assembly.js

@@ -6,7 +6,7 @@ import { compileInterruptOn } from "./tool/interrupt-policy.js";
 import { extractToolFallbackContext, extractVisibleOutput } from "../parsing/output-parsing.js";
 import { isRecord } from "../../utils/object.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
-import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
+import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
 export function buildBuiltinTaskSubagentMiddleware(input) {
     const { selectedSubagent, builtinBackend, summarizationModel } = input;
@@ -105,24 +105,26 @@ export async function resolveSubagents(input) {
     }));
 }
 export async function invokeBuiltinTaskTool(input) {
-    if (!isDeepAgentBinding(input.binding)) {
+    if (!isDeepAgentBinding(input.binding) || getBindingExecutionKind(input.binding) !== "deepagent") {
         throw new Error("The built-in task tool is only available for deepagent bindings.");
     }
-    const params = getBindingDeepAgentParams(input.binding);
-    if (!params) {
+    const primaryModel = getBindingPrimaryModel(input.binding);
+    const primaryTools = getBindingPrimaryTools(input.binding);
+    const compiledSubagents = getBindingSubagents(input.binding);
+    if (!primaryModel) {
         throw new Error(`Agent ${input.binding.agent.id} has no deepagent params`);
     }
     const typedInput = isRecord(input.toolInput) ? input.toolInput : {};
     const description = typeof typedInput.description === "string" ? typedInput.description : "";
     const subagentType = typeof typedInput.subagent_type === "string" ? typedInput.subagent_type : "";
     const builtinBackend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
-    const resolvedSubagents = await input.resolveSubagents(params.subagents, input.binding);
+    const resolvedSubagents = await input.resolveSubagents(compiledSubagents, input.binding);
     const selectedSubagent = resolvedSubagents.find((subagent) => subagent.name === subagentType);
     if (!selectedSubagent) {
         const allowed = resolvedSubagents.map((subagent) => subagent.name);
         throw new Error(`Error: invoked agent of type ${subagentType}, the only allowed types are ${allowed.map((name) => `\`${name}\``).join(", ")}`);
     }
-    const resolvedHostModel = selectedSubagent.model ? undefined : await input.resolveModel(params.model);
+    const resolvedHostModel = selectedSubagent.model ? undefined : await input.resolveModel(primaryModel);
     const summarizationModel = selectedSubagent.model ?? resolvedHostModel;
     const middleware = buildBuiltinTaskSubagentMiddleware({
         selectedSubagent,
@@ -131,7 +133,7 @@ export async function invokeBuiltinTaskTool(input) {
     });
     const runnable = createAgent({
         model: (selectedSubagent.model ?? resolvedHostModel),
-        tools: (selectedSubagent.tools ?? input.resolveTools(params.tools, input.binding)),
+        tools: (selectedSubagent.tools ?? input.resolveTools(primaryTools, input.binding)),
         systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
         middleware: middleware,
         responseFormat: selectedSubagent.responseFormat,
@@ -163,29 +165,30 @@ export async function resolveAutomaticSummarizationMiddleware(input) {
     return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], input.createDeclaredMiddlewareResolverOptions(input.binding));
 }
 export async function resolveLangChainAutomaticMiddleware(input) {
-    const params = getBindingLangChainParams(input.binding);
-    if (!params) {
+    const primaryModel = getBindingPrimaryModel(input.binding);
+    const primaryTools = getBindingPrimaryTools(input.binding);
+    if (!isLangChainBinding(input.binding) || !primaryModel) {
         return [];
     }
     const delegationCompatibility = resolveLangChainDelegationCompatibility({
-        model: params.model,
-        subagents: params.subagents,
-        generalPurposeAgent: params.generalPurposeAgent,
-        taskDescription: params.taskDescription,
+        model: primaryModel,
+        subagents: getBindingSubagents(input.binding),
+        generalPurposeAgent: getBindingGeneralPurposeAgent(input.binding),
+        taskDescription: getBindingTaskDescription(input.binding),
     });
     const automaticMiddleware = [];
     automaticMiddleware.push(createPatchToolCallsMiddleware());
     automaticMiddleware.push(...(await input.resolveAutomaticSummarizationMiddleware(input.binding)));
     automaticMiddleware.push(...buildLangChainContextMiddleware({
         binding: input.binding,
-        skills: params.skills,
-        memory: params.memory,
+        skills: getBindingSkills(input.binding),
+        memory: getBindingMemorySources(input.binding),
         resolveFilesystemBackend: input.resolveFilesystemBackend,
     }));
     if (bindingHasLangChainSubagentSupport(input.binding)) {
         automaticMiddleware.push(createSubAgentMiddleware({
-            defaultModel: (await input.resolveModel(params.model)),
-            defaultTools: input.resolveTools(params.tools, input.binding),
+            defaultModel: (await input.resolveModel(primaryModel)),
+            defaultTools: input.resolveTools(primaryTools, input.binding),
             defaultInterruptOn: getBindingInterruptCompatibilityRules(input.binding),
             subagents: (await input.resolveSubagents(delegationCompatibility.subagents ?? [], input.binding)),
             generalPurposeAgent: delegationCompatibility.generalPurposeAgent,

package/dist/runtime/adapter/model/invocation-request.js

@@ -1,3 +1,4 @@
+import { getBindingSkills } from "../../support/compiled-binding.js";
 import { extractMessageText, normalizeMessageContent } from "../../../utils/message-content.js";
 import { readSkillMetadata } from "../../support/skill-metadata.js";
 export function buildAgentMessages(history, input) {
@@ -14,7 +15,7 @@ export function buildSlashCommandSkillInstruction(binding, input) {
     }
     const invokedName = match[1].toLowerCase();
     const argumentText = match[2]?.trim() ?? "";
-    const skillPaths = binding.deepAgentParams?.skills ?? binding.langchainAgentParams?.skills ?? [];
+    const skillPaths = getBindingSkills(binding);
     const matchedSkillPath = skillPaths.find((skillPath) => readSkillMetadata(skillPath).name.toLowerCase() === invokedName);
     if (!matchedSkillPath) {
         return undefined;

package/dist/runtime/adapter/runtime-shell.js

@@ -2,7 +2,7 @@ import { setTimeout as sleep } from "node:timers/promises";
 import { extractVisibleOutput, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION } from "../parsing/output-parsing.js";
 import { readStreamDelta } from "../parsing/stream-event-parsing.js";
 import { computeRemainingTimeoutMs, isRetryableProviderError, resolveProviderRetryPolicy } from "./resilience.js";
-import { getBindingDeepAgentParams, getBindingLangChainParams, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
+import { isDeepAgentBinding, isLangChainBinding, withUpdatedBindingExecutionParams, } from "../support/compiled-binding.js";
 export class RuntimeOperationTimeoutError extends Error {
     operation;
     timeoutMs;
@@ -134,24 +134,16 @@ export function createModelFallbackRunnable(model) {
 }
 export function applyStrictToolJsonInstruction(binding) {
     if (isLangChainBinding(binding)) {
-        const params = getBindingLangChainParams(binding);
-        return {
-            ...binding,
-            langchainAgentParams: {
-                ...params,
-                systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
-            },
-        };
+        return withUpdatedBindingExecutionParams(binding, (params) => ({
+            ...params,
+            systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+        }));
     }
     if (isDeepAgentBinding(binding)) {
-        const params = getBindingDeepAgentParams(binding);
-        return {
-            ...binding,
-            deepAgentParams: {
-                ...params,
-                systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
-            },
-        };
+        return withUpdatedBindingExecutionParams(binding, (params) => ({
+            ...params,
+            systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+        }));
     }
     return binding;
 }

package/dist/runtime/agent-runtime-adapter.js

@@ -18,7 +18,7 @@ export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillS
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingExecutionKind, getBindingExecutionParams, getBindingFilesystemConfig, getBindingInterruptCompatibilityRules, getBindingPrimaryModel, getBindingSkills, getBindingSubagents, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "write_todos",
@@ -37,17 +37,43 @@ export function resolveRunnableCheckpointer(options, binding) {
 export function resolveRunnableInterruptOn(binding) {
     return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
 }
+function buildUpstreamCreateBaseParams(binding, compileOnlyFields) {
+    const executionParams = getBindingExecutionParams(binding);
+    if (!executionParams) {
+        throw new Error(`Agent ${binding.agent.id} has no compiled execution params`);
+    }
+    const source = executionParams;
+    const passthrough = typeof source.passthrough === "object" && source.passthrough
+        ? source.passthrough
+        : undefined;
+    const stripped = Object.fromEntries(Object.entries(source).filter(([key]) => key !== "passthrough" && !compileOnlyFields.includes(key)));
+    return {
+        ...(passthrough ?? {}),
+        ...stripped,
+    };
+}
 export function buildLangChainCreateParams(input) {
-    const langchainParams = getBindingLangChainParams(input.binding);
-    if (!langchainParams) {
+    const executionKind = getBindingExecutionKind(input.binding);
+    const executionParams = getBindingExecutionParams(input.binding);
+    if (executionKind !== "langchain-v1" || !executionParams) {
         throw new Error(`Agent ${input.binding.agent.id} has no langchain params`);
     }
-    const { model: _compiledModel, tools: _compiledTools, middleware: _compiledMiddleware, interruptOn: _compiledInterruptOn, filesystem: _filesystem, subagents: _subagents, memory: _memory, skills: _skills, generalPurposeAgent: _generalPurposeAgent, taskDescription: _taskDescription, passthrough, systemPrompt, ...upstreamParams } = langchainParams;
+    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
+        "model",
+        "tools",
+        "middleware",
+        "interruptOn",
+        "filesystem",
+        "subagents",
+        "memory",
+        "skills",
+        "generalPurposeAgent",
+        "taskDescription",
+    ]);
     return {
-        ...(passthrough ?? {}),
-        ...(input.passthroughOverride ?? {}),
         ...upstreamParams,
-        systemPrompt: input.systemPromptOverride ?? systemPrompt,
+        ...(input.passthroughOverride ?? {}),
+        systemPrompt: input.systemPromptOverride ?? executionParams.systemPrompt,
         model: input.resolvedModel,
         tools: input.resolvedTools,
         middleware: input.resolvedMiddleware,
@@ -56,14 +82,25 @@ export function buildLangChainCreateParams(input) {
     };
 }
 export function buildDeepAgentCreateParams(input) {
-    const deepAgentParams = getBindingDeepAgentParams(input.binding);
-    if (!deepAgentParams) {
+    const executionKind = getBindingExecutionKind(input.binding);
+    if (executionKind !== "deepagent" || !getBindingExecutionParams(input.binding)) {
         throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
     }
-    const deepAgentParamsWithCompatFields = deepAgentParams;
-    const { model: _compiledModel, tools: _compiledTools, middleware: _compiledMiddleware, subagents: _compiledSubagents, interruptOn: _compiledInterruptOn, skills: _compiledSkills, backend: _compiledBackend, store: _compiledStore, generalPurposeAgent: _generalPurposeAgent, taskDescription: _taskDescription, passthrough, ...upstreamParams } = deepAgentParamsWithCompatFields;
+    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
+        "model",
+        "tools",
+        "middleware",
+        "subagents",
+        "interruptOn",
+        "skills",
+        "backend",
+        "store",
+        // These do not belong to DeepAgents top-level create params even if
+        // compatibility fixtures stuff them into compiled deepagent params.
+        "generalPurposeAgent",
+        "taskDescription",
+    ]);
     return {
-        ...(passthrough ?? {}),
         ...upstreamParams,
         skills: input.resolvedSkills,
         model: input.resolvedModel,
@@ -145,7 +182,7 @@ export class AgentRuntimeAdapter {
         return resolved;
     }
     resolveFilesystemBackend(binding) {
-        const filesystemConfig = getBindingLangChainParams(binding)?.filesystem;
+        const filesystemConfig = getBindingFilesystemConfig(binding);
         const configuredRootDir = typeof filesystemConfig?.rootDir === "string" && filesystemConfig.rootDir.trim().length > 0
             ? filesystemConfig.rootDir
             : undefined;
@@ -257,19 +294,21 @@ export class AgentRuntimeAdapter {
         });
     }
     async createLangChainRunnable(binding, options = {}) {
-        const langchainParams = getBindingLangChainParams(binding);
-        if (!langchainParams) {
+        const executionKind = getBindingExecutionKind(binding);
+        const primaryModel = getBindingPrimaryModel(binding);
+        const primaryTools = getBindingPrimaryTools(binding);
+        if (executionKind !== "langchain-v1" || !primaryModel) {
             throw new Error(`Agent ${binding.agent.id} has no langchain params`);
         }
         const interruptOn = resolveRunnableInterruptOn(binding);
-        const resolvedModel = await this.resolveModel(langchainParams.model);
-        const resolvedTools = this.resolveTools(langchainParams.tools, binding);
+        const resolvedModel = await this.resolveModel(primaryModel);
+        const resolvedTools = this.resolveTools(primaryTools, binding);
         const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn);
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
         const resolvedStore = this.options.storeResolver?.(binding);
         const model = resolvedModel;
         if (resolvedTools.length > 0 && typeof model.bindTools !== "function") {
-            throw new Error(`Agent ${binding.agent.id} configures ${resolvedTools.length} tool(s), but resolved model ${langchainParams.model.id} does not support tool binding.`);
+            throw new Error(`Agent ${binding.agent.id} configures ${resolvedTools.length} tool(s), but resolved model ${primaryModel.id} does not support tool binding.`);
         }
         return createAgent(buildLangChainCreateParams({
             binding,
@@ -292,14 +331,16 @@ export class AgentRuntimeAdapter {
         return this.createDeepAgentRunnable(binding);
     }
     async createDeepAgentRunnable(binding) {
-        const deepAgentParams = getBindingDeepAgentParams(binding);
-        if (!deepAgentParams) {
+        const executionKind = getBindingExecutionKind(binding);
+        const primaryModel = getBindingPrimaryModel(binding);
+        const primaryTools = getBindingPrimaryTools(binding);
+        if (executionKind !== "deepagent" || !primaryModel) {
             throw new Error(`Agent ${binding.agent.id} has no runnable params`);
         }
-        const resolvedModel = await this.resolveModel(deepAgentParams.model);
-        const resolvedTools = this.resolveTools(deepAgentParams.tools, binding);
+        const resolvedModel = await this.resolveModel(primaryModel);
+        const resolvedTools = this.resolveTools(primaryTools, binding);
         const resolvedMiddleware = await this.resolveMiddleware(binding);
-        const resolvedSubagents = await this.resolveSubagents(deepAgentParams.subagents, binding);
+        const resolvedSubagents = await this.resolveSubagents(getBindingSubagents(binding), binding);
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
         const resolvedStore = this.options.storeResolver?.(binding);
         const resolvedBackend = this.options.backendResolver?.(binding);
@@ -308,7 +349,7 @@ export class AgentRuntimeAdapter {
             workspaceRoot: binding.harnessRuntime.workspaceRoot,
             runRoot: binding.harnessRuntime.runRoot,
             ownerId: binding.agent.id,
-            skillPaths: deepAgentParams.skills,
+            skillPaths: getBindingSkills(binding),
         }) ?? [];
         const deepAgentConfig = buildDeepAgentCreateParams({
             binding,

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/system/inventory.js

@@ -1,5 +1,5 @@
 import { readSkillMetadata } from "../../support/skill-metadata.js";
-import { getBindingPrimaryTools } from "../../support/compiled-binding.js";
+import { getBindingBackendConfig, getBindingPrimaryTools, getBindingSkills, getBindingSubagents } from "../../support/compiled-binding.js";
 import { assessSkillRequirements, } from "./skill-requirements.js";
 import { createRuntimeEnv } from "../../support/runtime-env.js";
 function listHostBindings(workspace) {
@@ -16,9 +16,7 @@ function dedupeTools(tools) {
     return Array.from(deduped.values());
 }
 function readBackendRequirementOptions(binding) {
-    const backend = binding.deepAgentParams?.backend && typeof binding.deepAgentParams.backend === "object"
-        ? binding.deepAgentParams.backend
-        : undefined;
+    const backend = getBindingBackendConfig(binding);
     if (!backend) {
         return {};
     }
@@ -75,7 +73,7 @@ export function listAgentSkills(workspace, agentId, options = {}) {
         return [];
     }
     const resolvedOptions = mergeRequirementOptions(binding, options);
-    return toSkillRecords(binding.deepAgentParams?.skills ?? binding.langchainAgentParams?.skills ?? [], resolvedOptions);
+    return toSkillRecords(getBindingSkills(binding), resolvedOptions);
 }
 function describeSubagent(subagent, parentAgentId, options = {}) {
     return {
@@ -89,7 +87,7 @@ function describeSubagent(subagent, parentAgentId, options = {}) {
 export function listSubagents(workspace, options = {}) {
     return listHostBindings(workspace).flatMap((binding) => {
         const resolvedOptions = mergeRequirementOptions(binding, options);
-        return (binding.deepAgentParams?.subagents ?? []).map((subagent) => describeSubagent(subagent, binding.agent.id, resolvedOptions));
+        return getBindingSubagents(binding).map((subagent) => describeSubagent(subagent, binding.agent.id, resolvedOptions));
     });
 }
 export function listAvailableAgents(workspace, options = {}) {

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, 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,8 +17,20 @@ 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;
+export declare function getBindingExecutionKind(binding: CompiledAgentBinding): "langchain-v1" | "deepagent" | undefined;
+export declare function withUpdatedBindingExecutionParams(binding: CompiledAgentBinding, updater: (params: LangChainAgentParams | DeepAgentParams) => LangChainAgentParams | DeepAgentParams): CompiledAgentBinding;
+export declare function getBindingSkills(binding: CompiledAgentBinding): string[];
+export declare function getBindingMemorySources(binding: CompiledAgentBinding): string[];
+export declare function getBindingSubagents(binding: CompiledAgentBinding): CompiledSubAgent[];
+export declare function getBindingGeneralPurposeAgent(binding: CompiledAgentBinding): boolean | undefined;
+export declare function getBindingTaskDescription(binding: CompiledAgentBinding): string | undefined;
+export declare function getBindingBackendConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
+export declare function getBindingFilesystemConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
 export declare function isLangChainBinding(binding: CompiledAgentBinding): boolean;
 export declare function isDeepAgentBinding(binding: CompiledAgentBinding): boolean;
 export declare function getBindingPrimaryTools(binding: CompiledAgentBinding): CompiledTool[];

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

@@ -3,21 +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 langchainParams = binding.langchainAgentParams ??
-        (adapterKind === "langchain-v1" && legacyAdapterParams
-            ? legacyAdapterParams
-            : undefined);
-    const deepAgentParams = 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 ?? [])
@@ -51,17 +110,92 @@ 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;
 }
 export function getBindingDeepAgentParams(binding) {
     return getBindingExecutionView(binding).deepAgentParams;
 }
+export function getBindingExecutionParams(binding) {
+    return getBindingExecutionView(binding).executionParams;
+}
+export function getBindingExecutionKind(binding) {
+    const execution = getBindingCanonicalExecution(binding);
+    return execution?.kind;
+}
+export function withUpdatedBindingExecutionParams(binding, updater) {
+    const kind = getBindingExecutionKind(binding);
+    const params = getBindingExecutionParams(binding);
+    if (!kind || !params) {
+        return binding;
+    }
+    const updatedParams = updater(params);
+    if (kind === "langchain-v1") {
+        return {
+            ...binding,
+            execution: {
+                kind,
+                params: updatedParams,
+            },
+            langchainAgentParams: updatedParams,
+        };
+    }
+    return {
+        ...binding,
+        execution: {
+            kind,
+            params: updatedParams,
+        },
+        deepAgentParams: updatedParams,
+    };
+}
+export function getBindingSkills(binding) {
+    const execution = getBindingExecutionParams(binding);
+    return Array.isArray(execution?.skills) ? execution.skills : [];
+}
+export function getBindingMemorySources(binding) {
+    const execution = getBindingExecutionParams(binding);
+    return Array.isArray(execution?.memory)
+        ? (execution.memory)
+        : [];
+}
+export function getBindingSubagents(binding) {
+    const execution = getBindingExecutionParams(binding);
+    return Array.isArray(execution?.subagents)
+        ? (execution.subagents)
+        : [];
+}
+export function getBindingGeneralPurposeAgent(binding) {
+    const execution = getBindingExecutionParams(binding);
+    const value = execution?.generalPurposeAgent;
+    return typeof value === "boolean" ? value : undefined;
+}
+export function getBindingTaskDescription(binding) {
+    const execution = getBindingExecutionParams(binding);
+    const value = execution?.taskDescription;
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+export function getBindingBackendConfig(binding) {
+    const execution = getBindingExecutionParams(binding);
+    const backend = execution?.backend;
+    return typeof backend === "object" && backend ? backend : undefined;
+}
+export function getBindingFilesystemConfig(binding) {
+    const execution = getBindingExecutionParams(binding);
+    const filesystem = execution?.filesystem;
+    return typeof filesystem === "object" && filesystem ? filesystem : undefined;
+}
 export function isLangChainBinding(binding) {
-    return getBindingAdapterKind(binding) === "langchain-v1" || Boolean(binding.langchainAgentParams);
+    return getBindingExecutionKind(binding) === "langchain-v1";
 }
 export function isDeepAgentBinding(binding) {
-    return getBindingAdapterKind(binding) === "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

@@ -1,5 +1,6 @@
 import { createPersistentId } from "../../utils/id.js";
 import { isDelegationCapableBinding } from "../../workspace/support/agent-capabilities.js";
+import { isDeepAgentBinding } from "./compiled-binding.js";
 export function renderRuntimeFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `runtime_error=${message}`.trim();
@@ -86,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) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
-    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,53 +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,
-            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,
-        deepAgentParams,
+        execution: executionBinding,
+        deepAgentParams: executionBinding.params,
     };
 }

package/package.json

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