@botbotgo/agent-harness 0.0.105 → 0.0.107

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.104";
+export declare const AGENT_HARNESS_VERSION = "0.0.106";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.104";
+export const AGENT_HARNESS_VERSION = "0.0.106";

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -15,6 +15,7 @@ export declare class AgentRuntimeAdapter {
     private readonly options;
     private readonly modelCache;
     private readonly runnableCache;
+    private readonly toolNameMappingCache;
     constructor(options?: RuntimeAdapterOptions);
     private getModelCacheKey;
     private invokeWithProviderRetry;
@@ -25,6 +26,7 @@ export declare class AgentRuntimeAdapter {
     private applyStrictToolJsonInstruction;
     private resolveModel;
     private resolveTools;
+    private getToolNameMapping;
     private resolveFilesystemBackend;
     private resolveBuiltinMiddlewareBackend;
     private createDeclaredMiddlewareResolverOptions;

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

@@ -39,6 +39,7 @@ export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
     runnableCache = new WeakMap();
+    toolNameMappingCache = new WeakMap();
     constructor(options = {}) {
         this.options = options;
     }
@@ -93,6 +94,15 @@ export class AgentRuntimeAdapter {
             resolveToolValues: this.options.toolResolver,
         });
     }
+    getToolNameMapping(binding) {
+        const cached = this.toolNameMappingCache.get(binding);
+        if (cached) {
+            return cached;
+        }
+        const resolved = buildToolNameMapping(getBindingPrimaryTools(binding));
+        this.toolNameMappingCache.set(binding, resolved);
+        return resolved;
+    }
     resolveFilesystemBackend(binding) {
         const filesystemConfig = getBindingLangChainParams(binding)?.filesystem;
         const configuredRootDir = typeof filesystemConfig?.rootDir === "string" && filesystemConfig.rootDir.trim().length > 0
@@ -274,7 +284,7 @@ export class AgentRuntimeAdapter {
         };
         const primaryTools = getBindingPrimaryTools(binding);
         const resolvedTools = this.resolveTools(primaryTools, binding);
-        const toolNameMapping = buildToolNameMapping(primaryTools);
+        const toolNameMapping = this.getToolNameMapping(binding);
         const executableTools = buildExecutableToolMap({
             primaryTools,
             resolvedTools,
@@ -311,7 +321,7 @@ export class AgentRuntimeAdapter {
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
         const primaryTools = getBindingPrimaryTools(binding);
-        const toolNameMapping = buildToolNameMapping(primaryTools);
+        const toolNameMapping = this.getToolNameMapping(binding);
         const primaryModel = getBindingPrimaryModel(binding);
         const forceInvokeFallback = isLangChainBinding(binding) &&
             primaryTools.length > 0 &&

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

@@ -2,7 +2,7 @@ import { createCheckpointerForConfig, createStoreForConfig } from "../../support
 import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "../../support/embedding-models.js";
 import { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "../../support/vector-stores.js";
 export function resolveStoreFromConfig(stores, storeConfig, runRoot) {
-    const cacheKey = storeConfig ? JSON.stringify(storeConfig) : undefined;
+    const cacheKey = storeConfig ? `${runRoot}:${JSON.stringify(storeConfig)}` : undefined;
     if (!storeConfig || !cacheKey) {
         return undefined;
     }

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

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

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

@@ -1,9 +1,8 @@
 import { AUTO_AGENT_ID } from "../../../contracts/types.js";
 import { inferRoutingBindings } from "../../support/harness-support.js";
-import { isRuntimeEntryBinding } from "../../support/runtime-entry.js";
 export function getDefaultHostAgentId(workspace, preferredHostAgentId) {
-    const preferredBinding = workspace.bindings.get(preferredHostAgentId);
-    if (preferredBinding && isRuntimeEntryBinding(preferredBinding)) {
+    const preferredBinding = preferredHostAgentId ? workspace.bindings.get(preferredHostAgentId) : undefined;
+    if (preferredBinding) {
         return preferredBinding.agent.id;
     }
     return inferRoutingBindings(workspace).primaryBinding?.agent.id ?? "agent";
@@ -14,7 +13,7 @@ export async function resolveSelectedAgentId(options) {
         if (threadId) {
             const thread = await getThreadSummary(threadId);
             const threadBinding = thread ? workspace.bindings.get(thread.agentId) : undefined;
-            if (thread?.agentId && threadBinding && isRuntimeEntryBinding(threadBinding)) {
+            if (thread?.agentId && threadBinding) {
                 return thread.agentId;
             }
         }

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

@@ -2,9 +2,8 @@ import { readSkillMetadata } from "../../support/skill-metadata.js";
 import { getBindingPrimaryTools } from "../../support/compiled-binding.js";
 import { assessSkillRequirements, } from "./skill-requirements.js";
 import { createRuntimeEnv } from "../../support/runtime-env.js";
-import { isRuntimeEntryBinding } from "../../support/runtime-entry.js";
 function listHostBindings(workspace) {
-    return Array.from(workspace.bindings.values()).filter((binding) => isRuntimeEntryBinding(binding));
+    return Array.from(workspace.bindings.values());
 }
 export function findAgentBinding(workspace, agentId) {
     return workspace.bindings.get(agentId);

package/dist/runtime/harness.d.ts

@@ -5,7 +5,6 @@ import type { RequirementAssessmentOptions } from "./harness/system/skill-requir
 export declare class AgentHarnessRuntime {
     private readonly workspace;
     private readonly runtimeAdapterOptions;
-    private static readonly DEFAULT_HOST_AGENT_ID;
     private static readonly BACKGROUND_EVENT_TYPES;
     private readonly eventBus;
     private readonly persistence;
@@ -15,6 +14,9 @@ export declare class AgentHarnessRuntime {
     private readonly stores;
     private readonly embeddingModels;
     private readonly vectorStores;
+    private readonly hostBindings;
+    private readonly defaultHostBinding?;
+    private readonly defaultRunRootValue;
     private readonly defaultStore;
     private readonly runtimeMemoryStore;
     private readonly routingRules;
@@ -31,7 +33,6 @@ export declare class AgentHarnessRuntime {
     private pendingRunInsertionOrder;
     private readonly pendingRunSlots;
     private runtimeEventSequence;
-    private listHostBindings;
     private defaultRunRoot;
     private getDefaultHostAgentId;
     private resolveSelectedAgentId;

package/dist/runtime/harness.js

@@ -23,7 +23,6 @@ import { getDefaultHostAgentId, resolveSelectedAgentId } from "./harness/run/rou
 import { resolveCheckpointer, resolveEmbeddingModel, resolveStore, resolveStoreFromConfig, resolveVectorStore, } from "./harness/run/resources.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
 import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig } from "./support/compiled-binding.js";
-import { isRuntimeEntryBinding } from "./support/runtime-entry.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
 import { initializeHarnessRuntime, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
@@ -32,7 +31,6 @@ import { deleteThreadRecord, getPublicApproval, getThreadRecord, listPublicAppro
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
-    static DEFAULT_HOST_AGENT_ID = "orchestra";
     static BACKGROUND_EVENT_TYPES = new Set([
         "run.created",
         "run.queued",
@@ -48,6 +46,9 @@ export class AgentHarnessRuntime {
     stores = new Map();
     embeddingModels = new Map();
     vectorStores = new Map();
+    hostBindings;
+    defaultHostBinding;
+    defaultRunRootValue;
     defaultStore;
     runtimeMemoryStore;
     routingRules;
@@ -64,15 +65,11 @@ export class AgentHarnessRuntime {
     pendingRunInsertionOrder = 0;
     pendingRunSlots = [];
     runtimeEventSequence = 0;
-    listHostBindings() {
-        return inferRoutingBindings(this.workspace).hostBindings;
-    }
     defaultRunRoot() {
-        return (this.listHostBindings()[0]?.harnessRuntime.runRoot ??
-            `${this.workspace.workspaceRoot}/run-data`);
+        return this.defaultRunRootValue;
     }
     getDefaultHostAgentId() {
-        return getDefaultHostAgentId(this.workspace, this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID);
+        return getDefaultHostAgentId(this.workspace, this.routingDefaultAgentId);
     }
     async resolveSelectedAgentId(input, requestedAgentId, threadId) {
         return resolveSelectedAgentId({
@@ -80,20 +77,23 @@ export class AgentHarnessRuntime {
             input,
             requestedAgentId,
             threadId,
-            preferredHostAgentId: this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
+            preferredHostAgentId: this.routingDefaultAgentId,
             getThreadSummary: (currentThreadId) => this.getSession(currentThreadId),
         });
     }
     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`;
         const runRoot = this.defaultRunRoot();
         this.persistence = new SqlitePersistence(runRoot);
-        const defaultStoreConfig = this.listHostBindings()[0]?.harnessRuntime.store;
+        const defaultStoreConfig = this.defaultHostBinding?.harnessRuntime.store;
         this.defaultStore = resolveStoreFromConfig(this.stores, defaultStoreConfig, runRoot) ?? new FileBackedStore(`${runRoot}/store.json`);
-        const runtimeMemoryStoreConfig = typeof this.listHostBindings()[0]?.harnessRuntime.runtimeMemory?.store === "object" &&
-            this.listHostBindings()[0]?.harnessRuntime.runtimeMemory?.store
-            ? this.listHostBindings()[0]?.harnessRuntime.runtimeMemory?.store
+        const runtimeMemoryStoreConfig = typeof this.defaultHostBinding?.harnessRuntime.runtimeMemory?.store === "object" &&
+            this.defaultHostBinding?.harnessRuntime.runtimeMemory?.store
+            ? this.defaultHostBinding.harnessRuntime.runtimeMemory.store
             : undefined;
         this.runtimeMemoryStore = resolveStoreFromConfig(this.stores, runtimeMemoryStoreConfig, runRoot) ?? this.defaultStore;
         this.resolvedRuntimeAdapterOptions = {
@@ -264,14 +264,14 @@ export class AgentHarnessRuntime {
         const configuredRule = this.routingRules.find((rule) => matchRoutingRule(rawInput, rule, options));
         if (configuredRule) {
             const configuredBinding = this.workspace.bindings.get(configuredRule.agentId);
-            if (configuredBinding && isRuntimeEntryBinding(configuredBinding)) {
+            if (configuredBinding) {
                 return configuredBinding.agent.id;
             }
         }
         const defaultBinding = this.routingDefaultAgentId
             ? this.workspace.bindings.get(this.routingDefaultAgentId)
             : undefined;
-        if (defaultBinding && isRuntimeEntryBinding(defaultBinding)) {
+        if (defaultBinding) {
             return defaultBinding.agent.id;
         }
         return this.getDefaultHostAgentId();

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

@@ -3,25 +3,49 @@ function asRecord(value) {
         ? value
         : undefined;
 }
+const bindingExecutionViewCache = new WeakMap();
+function deriveBindingExecutionView(binding) {
+    const cached = bindingExecutionViewCache.get(binding);
+    if (cached) {
+        return cached;
+    }
+    const adapterKind = binding.adapter?.kind ?? binding.agent.executionMode;
+    const adapterConfig = binding.adapter?.config ?? {};
+    const adapterParams = asRecord(adapterConfig.params);
+    const langchainParams = adapterKind === "langchain-v1" && adapterParams
+        ? adapterParams
+        : binding.langchainAgentParams;
+    const deepAgentParams = adapterKind === "deepagent" && adapterParams
+        ? adapterParams
+        : binding.deepAgentParams;
+    const primaryTools = langchainParams?.tools ?? deepAgentParams?.tools ?? [];
+    const view = {
+        adapterKind,
+        adapterConfig,
+        langchainParams,
+        deepAgentParams,
+        primaryTools,
+        primaryModel: langchainParams?.model ?? deepAgentParams?.model,
+        systemPrompt: langchainParams?.systemPrompt ?? deepAgentParams?.systemPrompt,
+        middlewareConfigs: langchainParams?.middleware ?? deepAgentParams?.middleware,
+        interruptCompatibilityRules: deepAgentParams?.interruptOn ??
+            binding.agent.langchainAgentConfig?.interruptOn,
+        storeConfig: deepAgentParams?.store ?? binding.harnessRuntime?.store,
+    };
+    bindingExecutionViewCache.set(binding, view);
+    return view;
+}
 export function getBindingAdapterKind(binding) {
-    return binding.adapter?.kind ?? binding.agent.executionMode;
+    return deriveBindingExecutionView(binding).adapterKind;
 }
 export function getBindingAdapterConfig(binding) {
-    return binding.adapter?.config ?? {};
+    return deriveBindingExecutionView(binding).adapterConfig;
 }
 export function getBindingLangChainParams(binding) {
-    const adapterParams = getBindingAdapterConfig(binding).params;
-    if (getBindingAdapterKind(binding) === "langchain-v1" && typeof adapterParams === "object" && adapterParams && !Array.isArray(adapterParams)) {
-        return adapterParams;
-    }
-    return binding.langchainAgentParams;
+    return deriveBindingExecutionView(binding).langchainParams;
 }
 export function getBindingDeepAgentParams(binding) {
-    const adapterParams = asRecord(getBindingAdapterConfig(binding).params);
-    if (getBindingAdapterKind(binding) === "deepagent" && adapterParams) {
-        return adapterParams;
-    }
-    return binding.deepAgentParams;
+    return deriveBindingExecutionView(binding).deepAgentParams;
 }
 export function isLangChainBinding(binding) {
     return getBindingAdapterKind(binding) === "langchain-v1" || Boolean(binding.langchainAgentParams);
@@ -30,30 +54,29 @@ export function isDeepAgentBinding(binding) {
     return getBindingAdapterKind(binding) === "deepagent" || Boolean(binding.deepAgentParams);
 }
 export function getBindingPrimaryTools(binding) {
-    return binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? [];
+    return deriveBindingExecutionView(binding).primaryTools;
 }
 export function getBindingPrimaryModel(binding) {
-    return binding.langchainAgentParams?.model ?? binding.deepAgentParams?.model;
+    return deriveBindingExecutionView(binding).primaryModel;
 }
 export function getBindingRuntimeModel(binding, slot) {
     return binding.harnessRuntime.models?.[slot];
 }
 export function getBindingSystemPrompt(binding) {
-    return binding.langchainAgentParams?.systemPrompt ?? binding.deepAgentParams?.systemPrompt;
+    return deriveBindingExecutionView(binding).systemPrompt;
 }
 export function getBindingMiddlewareConfigs(binding) {
-    return binding.langchainAgentParams?.middleware ?? binding.deepAgentParams?.middleware;
+    return deriveBindingExecutionView(binding).middlewareConfigs;
 }
 export function getBindingInterruptCompatibilityRules(binding) {
-    return binding.deepAgentParams?.interruptOn ??
-        binding.agent.langchainAgentConfig?.interruptOn;
+    return deriveBindingExecutionView(binding).interruptCompatibilityRules;
 }
 export function getBindingModelInit(binding) {
     return getBindingPrimaryModel(binding)?.init;
 }
 export function getBindingStoreConfig(binding) {
-    return binding.deepAgentParams?.store ?? binding.harnessRuntime.store;
+    return deriveBindingExecutionView(binding).storeConfig;
 }
 export function bindingHasSubagents(binding) {
-    return (binding.deepAgentParams?.subagents.length ?? 0) > 0;
+    return (getBindingDeepAgentParams(binding)?.subagents.length ?? 0) > 0;
 }

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

@@ -11,7 +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;
-    secondaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding | undefined;
-    researchBinding: import("../../contracts/workspace.js").CompiledAgentBinding | undefined;
     hostBindings: import("../../contracts/workspace.js").CompiledAgentBinding[];
 };

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

@@ -1,6 +1,5 @@
 import { createPersistentId } from "../../utils/id.js";
 import { isDelegationCapableBinding } from "../../workspace/support/agent-capabilities.js";
-import { isRuntimeEntryBinding } from "./runtime-entry.js";
 export function renderRuntimeFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `runtime_error=${message}`.trim();
@@ -87,38 +86,9 @@ export function createPendingApproval(threadId, runId, checkpointRef, input, int
     };
 }
 export function inferRoutingBindings(workspace) {
-    const runtimeEntryBindings = Array.from(workspace.bindings.values()).filter((binding) => isRuntimeEntryBinding(binding));
-    const orchestrationHosts = runtimeEntryBindings.filter((binding) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
-    const routingHosts = orchestrationHosts.length > 0 ? orchestrationHosts : runtimeEntryBindings;
-    const deepAgentHosts = routingHosts.filter((binding) => binding.agent.executionMode === "deepagent" || Boolean(binding.deepAgentParams));
-    const nonDeepAgentHosts = routingHosts.filter((binding) => !deepAgentHosts.includes(binding));
-    const researchBinding = routingHosts.find((binding) => binding.agent.id === "research-lite" || binding.agent.id === "research");
-    const directBinding = routingHosts.find((binding) => binding.agent.id === "direct");
-    const delegationHosts = routingHosts.filter((binding) => isDelegationCapableBinding(binding));
-    const deepAgentDelegationHosts = deepAgentHosts.filter((binding) => isDelegationCapableBinding(binding));
-    const nonDeepAgentDelegationHosts = nonDeepAgentHosts.filter((binding) => isDelegationCapableBinding(binding));
-    const lightweightHosts = routingHosts.filter((binding) => !isDelegationCapableBinding(binding));
-    const defaultOrchestratingHost = routingHosts.find((binding) => binding.agent.id === "orchestra") ??
-        deepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        deepAgentDelegationHosts[0] ??
-        deepAgentHosts[0] ??
-        nonDeepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        nonDeepAgentDelegationHosts[0] ??
-        nonDeepAgentHosts[0];
-    const delegationPreferredSecondary = deepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        deepAgentDelegationHosts[0] ??
-        nonDeepAgentDelegationHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
-        nonDeepAgentDelegationHosts[0] ??
-        delegationHosts[0];
-    const genericLightweightHost = lightweightHosts.find((binding) => binding.agent.id !== researchBinding?.agent.id);
-    const primaryBinding = defaultOrchestratingHost ?? directBinding ?? genericLightweightHost ?? routingHosts[0] ?? runtimeEntryBindings[0];
-    const secondaryBinding = genericLightweightHost && genericLightweightHost.agent.id !== primaryBinding?.agent.id
-        ? genericLightweightHost
-        : directBinding && directBinding.agent.id !== primaryBinding?.agent.id
-            ? directBinding
-            : delegationPreferredSecondary && delegationPreferredSecondary.agent.id !== primaryBinding?.agent.id
-                ? delegationPreferredSecondary
-                : routingHosts.find((binding) => binding.agent.id !== primaryBinding?.agent.id) ??
-                    (orchestrationHosts.length > 0 ? undefined : runtimeEntryBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id));
-    return { primaryBinding, secondaryBinding, researchBinding, hostBindings: runtimeEntryBindings };
+    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 };
 }

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

@@ -72,9 +72,6 @@ function resolveAgentRuntimeName(agent) {
     if (normalizedSourcePath.includes("/packages/framework/")) {
         return `core.${baseName}`;
     }
-    if (["direct", "orchestra", "research-lite"].includes(baseName)) {
-        return `core.${baseName}`;
-    }
     return baseName;
 }
 export function requireTools(tools, refs, ownerId) {
@@ -93,21 +90,20 @@ export function requireTools(tools, refs, ownerId) {
 }
 function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parentModel, parentMemory) {
     const ownMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
+    const execution = compileExecutionCore(agent, models, tools);
     return {
         name: resolveAgentRuntimeName(agent),
         description: agent.description,
-        systemPrompt: [resolvePromptValue(agent.deepAgentConfig?.systemPrompt), WORKSPACE_BOUNDARY_GUIDANCE].filter(Boolean).join("\n\n"),
-        tools: requireTools(tools, agent.toolRefs, agent.id),
-        model: agent.modelRef ? requireModel(models, agent.modelRef, agent.id) : parentModel,
-        interruptOn: agent.deepAgentConfig?.interruptOn,
+        systemPrompt: execution.systemPrompt ?? WORKSPACE_BOUNDARY_GUIDANCE,
+        tools: execution.tools,
+        model: agent.modelRef ? execution.model : parentModel,
+        interruptOn: resolveInterruptOn(agent),
         skills: compileAgentSkills(workspaceRoot, agent, parentSkills),
         memory: ownMemory.length > 0 ? ownMemory : parentMemory,
-        responseFormat: agent.deepAgentConfig?.responseFormat,
-        contextSchema: agent.deepAgentConfig?.contextSchema,
-        middleware: compileMiddlewareConfigs(agent.deepAgentConfig?.middleware, models, agent.id),
-        passthrough: typeof agent.deepAgentConfig?.passthrough === "object" && agent.deepAgentConfig.passthrough
-            ? { ...agent.deepAgentConfig.passthrough }
-            : undefined,
+        responseFormat: execution.responseFormat,
+        contextSchema: execution.contextSchema,
+        middleware: execution.middleware,
+        passthrough: execution.passthrough,
     };
 }
 function resolveDirectPrompt(agent) {
@@ -127,6 +123,45 @@ function resolveInterruptOn(agent) {
     return (agent.deepAgentConfig?.interruptOn ??
         agent.langchainAgentConfig?.interruptOn);
 }
+function resolveResponseFormat(agent) {
+    return agent.deepAgentConfig?.responseFormat ?? agent.langchainAgentConfig?.responseFormat;
+}
+function resolveContextSchema(agent) {
+    return agent.deepAgentConfig?.contextSchema ?? agent.langchainAgentConfig?.contextSchema;
+}
+function resolveCompiledMiddleware(agent, models) {
+    const middleware = agent.deepAgentConfig?.middleware ??
+        agent.langchainAgentConfig?.middleware;
+    return compileMiddlewareConfigs(middleware, models, agent.id);
+}
+function resolvePassthrough(agent) {
+    const passthrough = typeof agent.deepAgentConfig?.passthrough === "object" && agent.deepAgentConfig.passthrough
+        ? agent.deepAgentConfig.passthrough
+        : typeof agent.langchainAgentConfig?.passthrough === "object" && agent.langchainAgentConfig.passthrough
+            ? agent.langchainAgentConfig.passthrough
+            : undefined;
+    return passthrough ? { ...passthrough } : undefined;
+}
+function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory) {
+    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);
+    });
+}
+function compileExecutionCore(agent, models, tools) {
+    return {
+        model: requireModel(models, agent.modelRef, agent.id),
+        tools: requireTools(tools, agent.toolRefs, agent.id),
+        systemPrompt: resolveSystemPrompt(agent),
+        responseFormat: resolveResponseFormat(agent),
+        contextSchema: resolveContextSchema(agent),
+        middleware: resolveCompiledMiddleware(agent, models),
+        passthrough: resolvePassthrough(agent),
+    };
+}
 function resolveBackendConfig(agent, refs) {
     if (agent.executionMode !== "deepagent") {
         return undefined;
@@ -289,7 +324,11 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const resilience = getResilienceConfig(refs);
     const compiledAgentSkills = compileAgentSkills(workspaceRoot, agent);
     const compiledAgentMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
-    const compiledAgentModel = requireModel(models, agent.modelRef || (internalSubagent ? "model/default" : ""), agent.id);
+    const execution = compileExecutionCore({
+        ...agent,
+        modelRef: agent.modelRef || (internalSubagent ? "model/default" : ""),
+    }, models, tools);
+    const compiledAgentModel = execution.model;
     const backend = resolveBackendConfig(agent, refs);
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
@@ -326,28 +365,19 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         },
     };
     if (agent.executionMode !== "deepagent") {
-        const basePassthrough = typeof agent.langchainAgentConfig?.passthrough === "object" && agent.langchainAgentConfig.passthrough
-            ? { ...agent.langchainAgentConfig.passthrough }
-            : undefined;
         const langchainAgentParams = {
-            model: compiledAgentModel,
-            tools: requireTools(tools, agent.toolRefs, agent.id),
-            systemPrompt: resolveSystemPrompt(agent),
+            model: execution.model,
+            tools: execution.tools,
+            systemPrompt: execution.systemPrompt,
             stateSchema: agent.langchainAgentConfig?.stateSchema,
-            responseFormat: agent.langchainAgentConfig?.responseFormat,
-            contextSchema: agent.langchainAgentConfig?.contextSchema,
+            responseFormat: execution.responseFormat,
+            contextSchema: execution.contextSchema,
             filesystem: typeof agent.langchainAgentConfig?.filesystem === "object" && agent.langchainAgentConfig.filesystem
                 ? { ...agent.langchainAgentConfig.filesystem }
                 : undefined,
-            middleware: compileMiddlewareConfigs(agent.langchainAgentConfig?.middleware, models, agent.id),
-            passthrough: basePassthrough,
-            subagents: 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);
-            }),
+            middleware: execution.middleware,
+            passthrough: execution.passthrough,
+            subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory),
             memory: compiledAgentMemory,
             skills: compiledAgentSkills,
             generalPurposeAgent: typeof agent.langchainAgentConfig?.generalPurposeAgent === "boolean" ? agent.langchainAgentConfig.generalPurposeAgent : undefined,
@@ -373,23 +403,15 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         };
     }
     const deepAgentParams = {
-        model: compiledAgentModel,
-        tools: requireTools(tools, agent.toolRefs, agent.id),
-        systemPrompt: resolveSystemPrompt(agent),
-        responseFormat: agent.deepAgentConfig?.responseFormat,
-        contextSchema: agent.deepAgentConfig?.contextSchema,
-        middleware: compileMiddlewareConfigs(agent.deepAgentConfig?.middleware, models, agent.id),
-        passthrough: typeof agent.deepAgentConfig?.passthrough === "object" && agent.deepAgentConfig.passthrough
-            ? { ...agent.deepAgentConfig.passthrough }
-            : undefined,
+        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: 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);
-        }),
+        subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory),
         interruptOn: resolveInterruptOn(agent),
         ...(backend ? { backend: backend.config } : {}),
         ...(store ? { store: store.config } : {}),

package/package.json

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

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

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

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

@@ -1,3 +0,0 @@
-export function isRuntimeEntryBinding(binding) {
-    return Boolean(binding);
-}