@botbotgo/agent-harness 0.0.111 → 0.0.113

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

@@ -1,28 +1,23 @@
 import path from "node:path";
-import { Command, MemorySaver } from "@langchain/langgraph";
 import { createDeepAgent, FilesystemBackend, } from "deepagents";
 import { createAgent } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+import { assembleDeepAgentRunnable, assembleLangChainRunnable, } from "./adapter/flow/runnable-assembly.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
-import { finalizeInvocationResult } from "./adapter/invocation-result.js";
-import { invokeRuntimeWithLocalTools } from "./adapter/invoke-runtime.js";
-import { streamRuntimeExecution } from "./adapter/stream-runtime.js";
+import { executeRuntimeInvocation } from "./adapter/flow/invocation-flow.js";
+import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { buildDeepAgentRunnableConfig, buildLangChainRunnableConfig } from "./adapter/runnable-config.js";
 import { applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
 import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, resolveAutomaticSummarizationMiddleware as resolveAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainAutomaticMiddleware as resolveLangChainAutomaticMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
 import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
-import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
-import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
-import { countConfiguredTools, } from "./adapter/runtime-adapter-support.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
-import { buildBindingToolCatalog, buildBindingToolExecutionContext, resolveLangChainStreamContext, } from "./adapter/execution-context.js";
-export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
+import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
+export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 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, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingLangChainParams, 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",
@@ -35,12 +30,6 @@ const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "execute",
     "task",
 ]);
-function resolveBindingCheckpointer(options, binding) {
-    return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
-}
-function resolveBindingInterruptOn(binding) {
-    return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
-}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -222,22 +211,29 @@ export class AgentRuntimeAdapter {
         });
     }
     async createLangChainRunnable(binding, options = {}) {
-        const params = getBindingLangChainParams(binding);
-        const interruptOn = resolveBindingInterruptOn(binding);
-        const model = (await this.resolveModel(params.model));
-        const tools = this.resolveTools(params.tools, binding);
+        const assembly = await assembleLangChainRunnable({
+            binding,
+            runtimeAdapterOptions: this.options,
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveMiddleware: (currentBinding, interruptOn) => this.resolveMiddleware(currentBinding, interruptOn),
+            passthroughOverride: options.passthroughOverride,
+            systemPromptOverride: options.systemPromptOverride,
+        });
+        const model = assembly.resolvedModel;
+        const tools = assembly.resolvedTools;
         if (tools.length > 0 && typeof model.bindTools !== "function") {
-            throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${params.model.id} does not support tool binding.`);
+            throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${assembly.langchainParams.model.id} does not support tool binding.`);
         }
         return createAgent(buildLangChainRunnableConfig({
-            langchainParams: params,
+            langchainParams: assembly.langchainParams,
             resolvedModel: model,
             resolvedTools: tools,
-            resolvedMiddleware: await this.resolveMiddleware(binding, interruptOn),
-            resolvedCheckpointer: resolveBindingCheckpointer(this.options, binding),
-            resolvedStore: this.options.storeResolver?.(binding),
-            passthroughOverride: options.passthroughOverride,
-            systemPromptOverride: options.systemPromptOverride,
+            resolvedMiddleware: assembly.resolvedMiddleware,
+            resolvedCheckpointer: assembly.resolvedCheckpointer,
+            resolvedStore: assembly.resolvedStore,
+            passthroughOverride: assembly.passthroughOverride,
+            systemPromptOverride: assembly.systemPromptOverride,
         }));
     }
     async createRunnable(binding) {
@@ -250,27 +246,25 @@ export class AgentRuntimeAdapter {
         return this.createDeepAgentRunnable(binding);
     }
     async createDeepAgentRunnable(binding) {
-        const params = getBindingDeepAgentParams(binding);
-        if (!params) {
-            throw new Error(`Agent ${binding.agent.id} has no runnable params`);
-        }
-        const compatibleParams = applyDeepAgentDelegationPromptCompatibility(params.model, params);
+        const assembly = await assembleDeepAgentRunnable({
+            binding,
+            runtimeAdapterOptions: this.options,
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveMiddleware: (currentBinding, interruptOn) => this.resolveMiddleware(currentBinding, interruptOn),
+            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+        });
         const deepAgentConfig = buildDeepAgentRunnableConfig({
-            compatibleParams,
-            resolvedModel: await this.resolveModel(compatibleParams.model),
-            resolvedTools: this.resolveTools(compatibleParams.tools, binding),
-            resolvedMiddleware: await this.resolveMiddleware(binding),
-            resolvedSubagents: await this.resolveSubagents(compatibleParams.subagents, binding),
-            resolvedCheckpointer: resolveBindingCheckpointer(this.options, binding),
-            resolvedStore: this.options.storeResolver?.(binding),
-            resolvedBackend: this.options.backendResolver?.(binding),
-            resolvedInterruptOn: resolveBindingInterruptOn(binding),
-            resolvedSkills: (await materializeDeepAgentSkillSourcePaths({
-                workspaceRoot: binding.harnessRuntime.workspaceRoot,
-                runRoot: binding.harnessRuntime.runRoot,
-                ownerId: binding.agent.id,
-                skillPaths: compatibleParams.skills,
-            })) ?? [],
+            compatibleParams: assembly.compatibleParams,
+            resolvedModel: assembly.resolvedModel,
+            resolvedTools: assembly.resolvedTools,
+            resolvedMiddleware: assembly.resolvedMiddleware,
+            resolvedSubagents: assembly.resolvedSubagents,
+            resolvedCheckpointer: assembly.resolvedCheckpointer,
+            resolvedStore: assembly.resolvedStore,
+            resolvedBackend: assembly.resolvedBackend,
+            resolvedInterruptOn: assembly.resolvedInterruptOn,
+            resolvedSkills: assembly.resolvedSkills,
         });
         return createDeepAgent(deepAgentConfig);
     }
@@ -290,9 +284,6 @@ export class AgentRuntimeAdapter {
         }
     }
     async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
-        const request = resumePayload === undefined
-            ? buildInvocationRequest(binding, history, input, options)
-            : new Command({ resume: resumePayload });
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding);
@@ -307,47 +298,27 @@ export class AgentRuntimeAdapter {
                 callRuntime,
             });
         };
-        const { primaryTools, toolNameMapping, executableTools, defersToUpstreamHitlExecution, } = buildBindingToolExecutionContext({
+        return executeRuntimeInvocation({
             binding,
+            input,
+            threadId,
+            runId,
+            resumePayload,
+            history,
+            invokeOptions: options,
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
-            context: options.context,
-        });
-        const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
-        const localOrUpstreamInvocation = await invokeRuntimeWithLocalTools({
-            binding,
-            request,
-            resumePayload,
-            primaryTools,
-            defersToUpstreamHitlExecution,
-            toolNameMapping,
-            executableTools,
-            builtinExecutableTools: builtinExecutableTools,
+            resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, currentOptions),
             callRuntimeWithToolParseRecovery,
         });
-        const result = localOrUpstreamInvocation.result;
-        const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];
-        if (!result) {
-            throw new Error("Agent invocation returned no result");
-        }
-        return finalizeInvocationResult({
-            bindingAgentId: binding.agent.id,
-            threadId,
-            runId,
-            result,
-            executedToolResults,
-        });
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
         const invokeTimeoutMs = resolveBindingTimeout(binding);
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-        const { primaryTools, toolNameMapping } = buildBindingToolCatalog({
+        const { primaryTools, toolNameMapping, forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveRuntimeStreamExecutionContext({
             binding,
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
-        });
-        const { forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveLangChainStreamContext({
-            binding,
             resolveModel: (model) => this.resolveModel(model),
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
         });
@@ -373,7 +344,7 @@ export class AgentRuntimeAdapter {
             getSystemPrompt: (activeBinding) => getBindingSystemPrompt(activeBinding),
             isLangChainBinding,
             isDeepAgentBinding,
-            countConfiguredTools,
+            countConfiguredTools: getBindingToolCount,
         });
     }
 }

package/dist/runtime/harness/system/inventory.d.ts

@@ -20,14 +20,14 @@ export type InventorySkillRecord = {
 export type InventoryAgentRecord = {
     id: string;
     description: string;
-    role: "agent" | "specialist";
+    parentAgentId?: string;
     tools: InventoryToolRecord[];
     skills: InventorySkillRecord[];
 };
 export declare function findAgentBinding(workspace: WorkspaceBundle, agentId: string): CompiledAgentBinding | undefined;
 export declare function listAgentTools(workspace: WorkspaceBundle, agentId: string): InventoryToolRecord[];
 export declare function listAgentSkills(workspace: WorkspaceBundle, agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
-export declare function listSpecialists(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): InventoryAgentRecord[];
+export declare function listSubagents(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): InventoryAgentRecord[];
 export declare function listAvailableAgents(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): InventoryAgentRecord[];
 export declare function describeWorkspaceInventory(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): {
     workspaceRoot: string;

package/dist/runtime/harness/system/inventory.js

@@ -77,30 +77,29 @@ export function listAgentSkills(workspace, agentId, options = {}) {
     const resolvedOptions = mergeRequirementOptions(binding, options);
     return toSkillRecords(binding.deepAgentParams?.skills ?? binding.langchainAgentParams?.skills ?? [], resolvedOptions);
 }
-function describeSubagent(subagent, options = {}) {
+function describeSubagent(subagent, parentAgentId, options = {}) {
     return {
         id: subagent.name,
         description: subagent.description,
-        role: "specialist",
+        parentAgentId,
         tools: dedupeTools(subagent.tools ?? []),
         skills: toSkillRecords(subagent.skills ?? [], options),
     };
 }
-export function listSpecialists(workspace, options = {}) {
+export function listSubagents(workspace, options = {}) {
     return listHostBindings(workspace).flatMap((binding) => {
         const resolvedOptions = mergeRequirementOptions(binding, options);
-        return (binding.deepAgentParams?.subagents ?? []).map((subagent) => describeSubagent(subagent, resolvedOptions));
+        return (binding.deepAgentParams?.subagents ?? []).map((subagent) => describeSubagent(subagent, binding.agent.id, resolvedOptions));
     });
 }
 export function listAvailableAgents(workspace, options = {}) {
     const topLevel = listHostBindings(workspace).map((binding) => ({
         id: binding.agent.id,
         description: binding.agent.description,
-        role: "agent",
         tools: listAgentTools(workspace, binding.agent.id),
         skills: listAgentSkills(workspace, binding.agent.id, options),
     }));
-    return [...topLevel, ...listSpecialists(workspace, options)];
+    return [...topLevel, ...listSubagents(workspace, options)];
 }
 export function describeWorkspaceInventory(workspace, options = {}) {
     return {

package/dist/runtime/parsing/stream-event-parsing.js

@@ -390,13 +390,13 @@ export function extractAgentStep(event) {
             return "preparing model request…";
         if (/RunnableLambda/i.test(name) || /^__start__$/.test(name))
             return null;
-        if (/specialist/i.test(name))
+        if (/(subagent|specialist)/i.test(name))
             return `starting ${humanizeEventName(name)}…`;
         if (/agent$/i.test(name))
             return `running ${humanizeEventName(name)}…`;
     }
     if (typed.event === "on_chain_end") {
-        if (/specialist/i.test(name))
+        if (/(subagent|specialist)/i.test(name))
             return `${humanizeEventName(name)} done`;
         if (/agent$/i.test(name) && !/^__start__$/.test(name))
             return `${humanizeEventName(name)} done`;

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

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams, RuntimeModelSlot } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
 export type BindingExecutionView = {
     adapterKind: string;
     adapterConfig: Record<string, unknown>;
@@ -25,7 +25,6 @@ export declare function isLangChainBinding(binding: CompiledAgentBinding): boole
 export declare function isDeepAgentBinding(binding: CompiledAgentBinding): boolean;
 export declare function getBindingPrimaryTools(binding: CompiledAgentBinding): CompiledTool[];
 export declare function getBindingPrimaryModel(binding: CompiledAgentBinding): CompiledModel | undefined;
-export declare function getBindingRuntimeModel(binding: CompiledAgentBinding, slot: RuntimeModelSlot): CompiledModel | undefined;
 export declare function getBindingSystemPrompt(binding: CompiledAgentBinding): string | undefined;
 export declare function getBindingMiddlewareConfigs(binding: CompiledAgentBinding): Array<Record<string, unknown>> | undefined;
 export declare function getBindingToolCount(binding: CompiledAgentBinding): number;

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

@@ -69,9 +69,6 @@ export function getBindingPrimaryTools(binding) {
 export function getBindingPrimaryModel(binding) {
     return getBindingExecutionView(binding).primaryModel;
 }
-export function getBindingRuntimeModel(binding, slot) {
-    return binding.harnessRuntime.models?.[slot];
-}
 export function getBindingSystemPrompt(binding) {
     return getBindingExecutionView(binding).systemPrompt;
 }

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

@@ -4,7 +4,7 @@ import { compileModel, compileTool } from "./resource-compilers.js";
 import { inferAgentCapabilities } from "./support/agent-capabilities.js";
 import { getAgentExecutionConfigValue, getAgentExecutionObject, getAgentExecutionString } from "./support/agent-execution-config.js";
 import { discoverSkillPaths } from "./support/discovery.js";
-import { compileAgentMemories, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, getRuntimeModelDefaults, getWorkspaceObject, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.js";
+import { compileAgentMemories, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, getWorkspaceObject, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.js";
 const WORKSPACE_BOUNDARY_GUIDANCE = "Keep repository and file exploration bounded to the current workspace root unless the user explicitly asks for broader host or filesystem access. " +
     "Do not inspect absolute paths outside the workspace, system directories, or unrelated repos by default. " +
     "Prefer workspace-local tools, relative paths, and the current repository checkout when analyzing code.";
@@ -87,8 +87,7 @@ export function requireTools(tools, refs, ownerId) {
     }
     return Array.from(deduped.values());
 }
-function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parentModel, parentMemory) {
-    const ownMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
+function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parentModel) {
     const execution = compileExecutionCore(agent, models, tools);
     return {
         name: resolveAgentRuntimeName(agent),
@@ -98,11 +97,8 @@ function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parent
         model: agent.modelRef ? execution.model : parentModel,
         interruptOn: resolveInterruptOn(agent),
         skills: compileAgentSkills(workspaceRoot, agent, parentSkills),
-        memory: ownMemory.length > 0 ? ownMemory : parentMemory,
         responseFormat: execution.responseFormat,
-        contextSchema: execution.contextSchema,
         middleware: execution.middleware,
-        passthrough: execution.passthrough,
     };
 }
 function resolveSystemPrompt(agent) {
@@ -129,13 +125,13 @@ function resolvePassthrough(agent) {
     const passthrough = getAgentExecutionObject(agent, "passthrough");
     return passthrough ? { ...passthrough } : undefined;
 }
-function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory) {
+function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel) {
     return agent.subagentRefs.map((ref) => {
         const subagent = agents.get(resolveRefId(ref));
         if (!subagent) {
             throw new Error(`Missing subagent ${ref} for agent ${agent.id}`);
         }
-        return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory);
+        return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel);
     });
 }
 function compileExecutionCore(agent, models, tools) {
@@ -233,7 +229,7 @@ function resolveCheckpointerConfig(agent, refs) {
     return { config: inlineAgentCheckpointer };
 }
 function resolveRuntimeMemoryConfig(agent, refs) {
-    const inlineRuntimeMemory = getAgentExecutionObject(agent, "runtimeMemory");
+    const inlineRuntimeMemory = agent.runtimeMemory ?? getAgentExecutionObject(agent, "runtimeMemory");
     if (inlineRuntimeMemory) {
         if (isRefConfig(inlineRuntimeMemory)) {
             return {
@@ -245,20 +241,6 @@ function resolveRuntimeMemoryConfig(agent, refs) {
     const runtimeMemoryDefaults = getRuntimeMemoryDefaults(refs);
     return runtimeMemoryDefaults ? { config: runtimeMemoryDefaults } : undefined;
 }
-function resolveRuntimeModelRefs(agent, refs) {
-    const merged = {
-        ...(getRuntimeModelDefaults(refs) ?? {}),
-        ...(agent.runtimeModelRefs ?? {}),
-    };
-    return Object.keys(merged).length > 0 ? merged : undefined;
-}
-function compileRuntimeModels(modelRefs, models, ownerId) {
-    if (!modelRefs) {
-        return undefined;
-    }
-    const compiled = Object.fromEntries(Object.entries(modelRefs).map(([slot, modelRef]) => [slot, requireModel(models, modelRef, ownerId)]));
-    return Object.keys(compiled).length > 0 ? compiled : undefined;
-}
 export function compileBinding(workspaceRoot, agent, agents, referencedSubagentIds, refs, models, tools) {
     const internalSubagent = referencedSubagentIds.has(agent.id);
     const runtimeDefaults = getRuntimeDefaults(refs);
@@ -274,8 +256,6 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runtimeMemory = resolveRuntimeMemoryConfig(agent, refs);
-    const runtimeModelRefs = resolveRuntimeModelRefs(agent, refs);
-    const runtimeModels = compileRuntimeModels(runtimeModelRefs, models, agent.id);
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
         ? path.resolve(workspaceRoot, agent.runRoot)
         : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
@@ -296,8 +276,6 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         harnessRuntime: {
             runRoot,
             workspaceRoot,
-            ...(runtimeModelRefs ? { modelRefs: runtimeModelRefs } : {}),
-            ...(runtimeModels ? { models: runtimeModels } : {}),
             capabilities: inferAgentCapabilities(agent),
             resilience,
             ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
@@ -317,7 +295,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
             middleware: execution.middleware,
             passthrough: execution.passthrough,
-            subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory),
+            subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
             memory: compiledAgentMemory,
             skills: compiledAgentSkills,
             generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "langchain-v1" }),
@@ -347,17 +325,14 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         responseFormat: execution.responseFormat,
         contextSchema: execution.contextSchema,
         middleware: execution.middleware,
-        passthrough: execution.passthrough,
         description: agent.description,
-        subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory),
+        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,
-        generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "deepagent" }),
-        taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "deepagent" }),
     };
     return {
         ...base,

package/dist/workspace/object-loader.js

@@ -151,9 +151,75 @@ const CONSUMED_AGENT_CONFIG_KEYS = [
     "generalPurposeAgent",
     "filesystem",
 ];
+const RESERVED_EXECUTION_KEYS = [
+    "backend",
+    "modelRef",
+    "tools",
+    "skills",
+    "memory",
+    "subagents",
+    "mcpServers",
+    "config",
+];
+const MIGRATED_EXECUTION_CONFIG_KEYS = [
+    "systemPrompt",
+    "checkpointer",
+    "interruptOn",
+    "stateSchema",
+    "responseFormat",
+    "contextSchema",
+    "includeAgentName",
+    "version",
+    "middleware",
+    "store",
+    "taskDescription",
+    "generalPurposeAgent",
+    "filesystem",
+];
 function readExecutionConfig(value) {
     return asMutableObject(value);
 }
+function normalizeAgentItemForMerge(item) {
+    const normalized = { ...item };
+    const execution = readExecutionConfig(normalized.execution);
+    if (!execution) {
+        return normalized;
+    }
+    const config = asMutableObject(execution.config);
+    const runtime = readRuntimeConfig(normalized);
+    if (config) {
+        for (const key of MIGRATED_EXECUTION_CONFIG_KEYS) {
+            if (!(key in config) || execution[key] !== undefined) {
+                continue;
+            }
+            execution[key] = cloneConfigValue(config[key]);
+            delete config[key];
+        }
+        if (config.runtimeMemory !== undefined && runtime?.runtimeMemory === undefined) {
+            const nextRuntime = runtime ?? {};
+            nextRuntime.runtimeMemory = cloneConfigValue(config.runtimeMemory);
+            normalized.runtime = nextRuntime;
+            delete config.runtimeMemory;
+        }
+    }
+    if (config && Object.keys(config).length > 0) {
+        execution.config = config;
+    }
+    else {
+        delete execution.config;
+    }
+    normalized.execution = execution;
+    return normalized;
+}
+function readExecutionAgentConfig(item) {
+    const execution = readExecutionConfig(item.execution) ?? {};
+    const config = asMutableObject(execution.config) ?? {};
+    const directExecutionConfig = Object.fromEntries(Object.entries(execution).filter(([key]) => !RESERVED_EXECUTION_KEYS.includes(key)));
+    return {
+        ...config,
+        ...directExecutionConfig,
+    };
+}
 function readExecutionValue(item, key, reader) {
     const execution = readExecutionConfig(item.execution);
     return reader(execution?.[key]);
@@ -161,19 +227,17 @@ function readExecutionValue(item, key, reader) {
 function readRuntimeConfig(item) {
     return asMutableObject(item.runtime);
 }
-function readRuntimeModelRefs(runtime) {
-    if (!runtime) {
-        return undefined;
+function readRuntimeMemoryConfig(item, runtime) {
+    if (typeof runtime?.runtimeMemory === "object" && runtime.runtimeMemory && !Array.isArray(runtime.runtimeMemory)) {
+        return cloneConfigValue(runtime.runtimeMemory);
     }
-    const modelRefs = {
-        ...(typeof runtime.planningModelRef === "string" && runtime.planningModelRef.trim()
-            ? { planning: runtime.planningModelRef.trim() }
-            : {}),
-        ...(typeof runtime.executionModelRef === "string" && runtime.executionModelRef.trim()
-            ? { execution: runtime.executionModelRef.trim() }
-            : {}),
-    };
-    return Object.keys(modelRefs).length > 0 ? modelRefs : undefined;
+    const legacyExecutionConfig = readExecutionAgentConfig(item);
+    if (typeof legacyExecutionConfig.runtimeMemory === "object" &&
+        legacyExecutionConfig.runtimeMemory &&
+        !Array.isArray(legacyExecutionConfig.runtimeMemory)) {
+        return cloneConfigValue(legacyExecutionConfig.runtimeMemory);
+    }
+    return undefined;
 }
 function cloneConfigValue(value) {
     if (Array.isArray(value)) {
@@ -239,12 +303,15 @@ function resolveExecutionBackend(item, current) {
     }
     return undefined;
 }
-function readSharedAgentConfigFields(config) {
+function readSharedAgentConfigFields(config, options = {}) {
     return {
         ...(typeof config.store === "object" && config.store ? { store: config.store } : {}),
-        ...(typeof config.runtimeMemory === "object" && config.runtimeMemory ? { runtimeMemory: config.runtimeMemory } : {}),
-        ...(typeof config.taskDescription === "string" && config.taskDescription.trim() ? { taskDescription: config.taskDescription } : {}),
-        ...(typeof config.generalPurposeAgent === "boolean" ? { generalPurposeAgent: config.generalPurposeAgent } : {}),
+        ...(options.includeDelegationControls && typeof config.taskDescription === "string" && config.taskDescription.trim()
+            ? { taskDescription: config.taskDescription }
+            : {}),
+        ...(options.includeDelegationControls && typeof config.generalPurposeAgent === "boolean"
+            ? { generalPurposeAgent: config.generalPurposeAgent }
+            : {}),
     };
 }
 function readSharedAgentConfig(config) {
@@ -268,11 +335,11 @@ function readSharedAgentConfig(config) {
     };
 }
 function readAgentConfig(item, options = {}) {
-    const config = readExecutionValue(item, "config", asMutableObject) ?? {};
+    const config = readExecutionAgentConfig(item);
     const passthrough = readPassthroughConfig(config, [...CONSUMED_AGENT_CONFIG_KEYS]);
     return {
         ...readSharedAgentConfig(config),
-        ...readSharedAgentConfigFields(config),
+        ...readSharedAgentConfigFields(config, { includeDelegationControls: options.includeDelegationControls }),
         ...(options.includeObjectBackend && typeof config.backend === "object" && config.backend ? { backend: config.backend } : {}),
         ...(passthrough ? { passthrough } : {}),
     };
@@ -286,7 +353,7 @@ export function parseAgentItem(item, sourcePath) {
     return {
         id: String(item.id),
         executionMode: executionMode,
-        runtimeModelRefs: readRuntimeModelRefs(runtime),
+        runtimeMemory: readRuntimeMemoryConfig(item, runtime),
         capabilities: readCapabilities(item.capabilities) ?? (executionMode === "deepagent"
             ? { delegation: true, memory: true }
             : { delegation: true, memory: true }),
@@ -299,8 +366,11 @@ export function parseAgentItem(item, sourcePath) {
         memorySources: readExecutionValue(item, "memory", readPathArray).map((entry) => resolveModuleRelativePath(entry, moduleRoot)),
         subagentRefs,
         subagentPathRefs,
-        langchainAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item), moduleRoot),
-        deepAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, { includeObjectBackend: true }), moduleRoot),
+        langchainAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, { includeDelegationControls: true }), moduleRoot),
+        deepAgentConfig: normalizeModuleAgentConfig(readAgentConfig(item, {
+            includeObjectBackend: true,
+            includeDelegationControls: false,
+        }), moduleRoot),
         sourcePath,
     };
 }
@@ -347,11 +417,12 @@ function mergeRawItemRecord(records, key, item, sourcePath) {
     return mergedRecord;
 }
 function mergeAgentRecord(records, item, sourcePath) {
-    const id = typeof item.id === "string" ? item.id : undefined;
+    const normalizedItem = normalizeAgentItemForMerge(item);
+    const id = typeof normalizedItem.id === "string" ? normalizedItem.id : undefined;
     if (!id) {
         return null;
     }
-    return mergeRawItemRecord(records, id, item, sourcePath);
+    return mergeRawItemRecord(records, id, normalizedItem, sourcePath);
 }
 function mergeWorkspaceObjectRecord(records, workspaceObject, item, sourcePath) {
     mergeRawItemRecord(records, `${workspaceObject.kind}/${workspaceObject.id}`, item, sourcePath);

package/dist/workspace/support/workspace-ref-utils.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedAgentObject, RuntimeModelRefMap, WorkspaceObject } from "../../contracts/types.js";
+import type { ParsedAgentObject, WorkspaceObject } from "../../contracts/types.js";
 export type RoutingRule = {
     agentId: string;
     equals?: string[];
@@ -34,7 +34,6 @@ export type ResilienceConfig = {
 export declare function getWorkspaceObject(refs: Map<string, WorkspaceObject | ParsedAgentObject>, ref: string | undefined): WorkspaceObject | undefined;
 export declare function getRuntimeDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
 export declare function getRuntimeMemoryDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
-export declare function getRuntimeModelDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): RuntimeModelRefMap | undefined;
 export declare function getRecoveryConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): RecoveryConfig;
 export declare function getConcurrencyConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ConcurrencyConfig;
 export declare function getResilienceConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ResilienceConfig;

package/dist/workspace/support/workspace-ref-utils.js

@@ -36,18 +36,6 @@ export function getRuntimeMemoryDefaults(refs) {
     }
     return runtimeMemories[0].value;
 }
-export function getRuntimeModelDefaults(refs) {
-    const runtimeDefaults = getRuntimeDefaults(refs);
-    const modelRefs = {
-        ...(typeof runtimeDefaults?.planningModelRef === "string" && runtimeDefaults.planningModelRef.trim()
-            ? { planning: runtimeDefaults.planningModelRef.trim() }
-            : {}),
-        ...(typeof runtimeDefaults?.executionModelRef === "string" && runtimeDefaults.executionModelRef.trim()
-            ? { execution: runtimeDefaults.executionModelRef.trim() }
-            : {}),
-    };
-    return Object.keys(modelRefs).length > 0 ? modelRefs : undefined;
-}
 export function getRecoveryConfig(refs) {
     const runtimeDefaults = getRuntimeDefaults(refs);
     const recovery = typeof runtimeDefaults?.recovery === "object" && runtimeDefaults.recovery