@botbotgo/agent-harness 0.0.117 → 0.0.118

package/dist/contracts/workspace.d.ts

@@ -180,12 +180,20 @@ 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>;
     };
+    execution?: CompiledExecutionBinding;
     langchainAgentParams?: LangChainAgentParams;
     deepAgentParams?: DeepAgentParams;
     harnessRuntime: {

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.117";

package/dist/package-version.js

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

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/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/support/compiled-binding.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
 export type BindingExecutionView = {
     adapterKind: string;
     langchainParams?: LangChainAgentParams;
@@ -19,6 +19,16 @@ export declare function getBindingExecutionView(binding: CompiledAgentBinding):
 export declare function getBindingAdapterKind(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

@@ -10,11 +10,14 @@ function deriveBindingExecutionView(binding) {
     }
     const adapterKind = binding.adapter?.kind ?? binding.agent.executionMode;
     const legacyAdapterParams = getLegacyAdapterParams(binding);
-    const langchainParams = binding.langchainAgentParams ??
+    const compiledExecution = binding.execution;
+    const langchainParams = (compiledExecution?.kind === "langchain-v1" ? compiledExecution.params : undefined) ??
+        binding.langchainAgentParams ??
         (adapterKind === "langchain-v1" && legacyAdapterParams
             ? legacyAdapterParams
             : undefined);
-    const deepAgentParams = binding.deepAgentParams ??
+    const deepAgentParams = (compiledExecution?.kind === "deepagent" ? compiledExecution.params : undefined) ??
+        binding.deepAgentParams ??
         (adapterKind === "deepagent" && legacyAdapterParams
             ? legacyAdapterParams
             : undefined);
@@ -57,11 +60,89 @@ export function getBindingLangChainParams(binding) {
 export function getBindingDeepAgentParams(binding) {
     return getBindingExecutionView(binding).deepAgentParams;
 }
+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;
+}
+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 getBindingAdapterKind(binding) === "langchain-v1" || binding.execution?.kind === "langchain-v1" || Boolean(binding.langchainAgentParams);
 }
 export function isDeepAgentBinding(binding) {
-    return getBindingAdapterKind(binding) === "deepagent" || Boolean(binding.deepAgentParams);
+    return getBindingAdapterKind(binding) === "deepagent" || binding.execution?.kind === "deepagent" || Boolean(binding.deepAgentParams);
 }
 export function getBindingPrimaryTools(binding) {
     return getBindingExecutionView(binding).primaryTools;

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();
@@ -87,7 +88,7 @@ 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 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 };

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

@@ -300,6 +300,10 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         };
         return {
             ...base,
+            execution: {
+                kind: "langchain-v1",
+                params: langchainAgentParams,
+            },
             langchainAgentParams,
         };
     }
@@ -322,6 +326,10 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     };
     return {
         ...base,
+        execution: {
+            kind: "deepagent",
+            params: deepAgentParams,
+        },
         deepAgentParams,
     };
 }

package/package.json

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