@botbotgo/agent-harness 0.0.106 → 0.0.108

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.105";
+export declare const AGENT_HARNESS_VERSION = "0.0.107";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.105";
+export const AGENT_HARNESS_VERSION = "0.0.107";

package/dist/runtime/adapter/deepagent-runnable-config.d.ts

@@ -10,21 +10,4 @@ export declare function buildDeepAgentRunnableConfig(params: {
     resolvedBackend: unknown;
     resolvedInterruptOn: unknown;
     resolvedSkills: string[];
-}): {
-    model: never;
-    tools: never;
-    systemPrompt: string | undefined;
-    responseFormat: never;
-    contextSchema: never;
-    middleware: never;
-    subagents: never;
-    checkpointer: never;
-    store: never;
-    backend: never;
-    interruptOn: never;
-    name: string;
-    memory: string[];
-    skills: string[];
-    generalPurposeAgent: boolean | undefined;
-    taskDescription: string | undefined;
-};
+}): Record<string, unknown>;

package/dist/runtime/adapter/deepagent-runnable-config.js

@@ -1,22 +1,29 @@
+import { buildResolvedRunnableConfig } from "./runnable-config.js";
 export function buildDeepAgentRunnableConfig(params) {
     const { compatibleParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedSubagents, resolvedCheckpointer, resolvedStore, resolvedBackend, resolvedInterruptOn, resolvedSkills, } = params;
-    return {
-        ...(compatibleParams.passthrough ?? {}),
-        model: resolvedModel,
-        tools: resolvedTools,
-        systemPrompt: compatibleParams.systemPrompt,
-        responseFormat: compatibleParams.responseFormat,
-        contextSchema: compatibleParams.contextSchema,
-        middleware: resolvedMiddleware,
-        subagents: resolvedSubagents,
-        checkpointer: resolvedCheckpointer,
-        store: resolvedStore,
-        backend: resolvedBackend,
-        interruptOn: resolvedInterruptOn,
-        name: compatibleParams.name,
-        memory: compatibleParams.memory,
-        skills: resolvedSkills,
-        generalPurposeAgent: compatibleParams.generalPurposeAgent,
-        taskDescription: compatibleParams.taskDescription,
-    };
+    return buildResolvedRunnableConfig({
+        passthrough: compatibleParams.passthrough ?? {},
+        staticConfig: {
+            systemPrompt: compatibleParams.systemPrompt,
+            responseFormat: compatibleParams.responseFormat,
+            contextSchema: compatibleParams.contextSchema,
+            name: compatibleParams.name,
+            memory: compatibleParams.memory,
+            skills: resolvedSkills,
+            generalPurposeAgent: compatibleParams.generalPurposeAgent,
+            taskDescription: compatibleParams.taskDescription,
+        },
+        resolved: {
+            resolvedModel: resolvedModel,
+            resolvedTools: resolvedTools,
+            resolvedMiddleware: resolvedMiddleware,
+            resolvedCheckpointer: resolvedCheckpointer,
+            resolvedStore: resolvedStore,
+        },
+        extraConfig: {
+            subagents: resolvedSubagents,
+            backend: resolvedBackend,
+            interruptOn: resolvedInterruptOn,
+        },
+    });
 }

package/dist/runtime/adapter/execution-context.d.ts

@@ -0,0 +1,27 @@
+import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
+import type { ToolNameMapping } from "./tool/tool-name-mapping.js";
+import { getBindingPrimaryModel } from "../support/compiled-binding.js";
+export declare function buildBindingToolExecutionContext(input: {
+    binding: CompiledAgentBinding;
+    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
+    getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;
+    context?: Record<string, unknown>;
+}): {
+    primaryTools: CompiledTool[];
+    resolvedTools: unknown[];
+    toolNameMapping: ToolNameMapping;
+    executableTools: Map<string, import("./invoke-runtime.js").ExecutableTool>;
+    defersToUpstreamHitlExecution: boolean;
+};
+export declare function resolveLangChainStreamContext(input: {
+    binding: CompiledAgentBinding;
+    resolveModel: (model: NonNullable<ReturnType<typeof getBindingPrimaryModel>>) => Promise<unknown>;
+    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
+}): Promise<{
+    primaryTools: CompiledTool[];
+    forceInvokeFallback: boolean;
+    canUseDirectModelStream: boolean;
+    langChainStreamModel: {
+        stream?: (input: unknown) => Promise<AsyncIterable<unknown>>;
+    } | undefined;
+}>;

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

@@ -0,0 +1,45 @@
+import { buildExecutableToolMap } from "./tool-resolution.js";
+import { getBindingLangChainParams, getBindingPrimaryModel, getBindingPrimaryTools, isLangChainBinding } from "../support/compiled-binding.js";
+export function buildBindingToolExecutionContext(input) {
+    const primaryTools = getBindingPrimaryTools(input.binding);
+    const resolvedTools = input.resolveTools(primaryTools, input.binding);
+    const toolNameMapping = input.getToolNameMapping(input.binding);
+    const executableTools = buildExecutableToolMap({
+        primaryTools,
+        resolvedTools,
+        toolNameMapping,
+        context: input.context,
+    });
+    return {
+        primaryTools,
+        resolvedTools,
+        toolNameMapping,
+        executableTools,
+        defersToUpstreamHitlExecution: primaryTools.some((tool) => tool.hitl?.enabled === true),
+    };
+}
+export async function resolveLangChainStreamContext(input) {
+    const primaryTools = getBindingPrimaryTools(input.binding);
+    const primaryModel = getBindingPrimaryModel(input.binding);
+    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))
+        : undefined;
+    const resolvedLangChainTools = langchainParams ? input.resolveTools(langchainParams.tools, input.binding) : [];
+    const canUseDirectModelStream = !!resolvedLangChainModel &&
+        (resolvedLangChainTools.length === 0 || typeof resolvedLangChainModel.bindTools !== "function");
+    const langChainStreamModel = resolvedLangChainModel && canUseDirectModelStream
+        ? resolvedLangChainModel
+        : resolvedLangChainModel && typeof resolvedLangChainModel.bindTools === "function" && resolvedLangChainTools.length > 0
+            ? resolvedLangChainModel.bindTools(resolvedLangChainTools)
+            : undefined;
+    return {
+        primaryTools,
+        forceInvokeFallback,
+        canUseDirectModelStream,
+        langChainStreamModel,
+    };
+}

package/dist/runtime/adapter/langchain-runnable-config.d.ts

@@ -8,18 +8,4 @@ export declare function buildLangChainRunnableConfig(params: {
     resolvedStore: unknown;
     passthroughOverride?: Record<string, unknown>;
     systemPromptOverride?: string;
-}): {
-    model: never;
-    tools: never;
-    systemPrompt: string | undefined;
-    stateSchema: never;
-    responseFormat: never;
-    contextSchema: never;
-    middleware: never;
-    checkpointer: never;
-    store: never;
-    includeAgentName: "inline" | undefined;
-    version: "v1" | "v2" | undefined;
-    name: string | undefined;
-    description: string;
-};
+}): Record<string, unknown>;

package/dist/runtime/adapter/langchain-runnable-config.js

@@ -1,19 +1,24 @@
+import { buildResolvedRunnableConfig } from "./runnable-config.js";
 export function buildLangChainRunnableConfig(params) {
     const { langchainParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedCheckpointer, resolvedStore, passthroughOverride, systemPromptOverride, } = params;
-    return {
-        ...(passthroughOverride ?? langchainParams.passthrough ?? {}),
-        model: resolvedModel,
-        tools: resolvedTools,
-        systemPrompt: systemPromptOverride ?? langchainParams.systemPrompt,
-        stateSchema: langchainParams.stateSchema,
-        responseFormat: langchainParams.responseFormat,
-        contextSchema: langchainParams.contextSchema,
-        middleware: resolvedMiddleware,
-        checkpointer: resolvedCheckpointer,
-        store: resolvedStore,
-        includeAgentName: langchainParams.includeAgentName,
-        version: langchainParams.version,
-        name: langchainParams.name,
-        description: langchainParams.description,
-    };
+    return buildResolvedRunnableConfig({
+        passthrough: (passthroughOverride ?? langchainParams.passthrough ?? {}),
+        staticConfig: {
+            systemPrompt: systemPromptOverride ?? langchainParams.systemPrompt,
+            stateSchema: langchainParams.stateSchema,
+            responseFormat: langchainParams.responseFormat,
+            contextSchema: langchainParams.contextSchema,
+            includeAgentName: langchainParams.includeAgentName,
+            version: langchainParams.version,
+            name: langchainParams.name,
+            description: langchainParams.description,
+        },
+        resolved: {
+            resolvedModel: resolvedModel,
+            resolvedTools: resolvedTools,
+            resolvedMiddleware: resolvedMiddleware,
+            resolvedCheckpointer: resolvedCheckpointer,
+            resolvedStore: resolvedStore,
+        },
+    });
 }

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

@@ -8,6 +8,28 @@ import { hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, is
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
+function buildLangChainContextMiddleware(params) {
+    const middleware = [];
+    const hasSkills = (params.compatibleParams.skills?.length ?? 0) > 0;
+    const hasMemory = (params.compatibleParams.memory?.length ?? 0) > 0;
+    if (!hasSkills && !hasMemory) {
+        return middleware;
+    }
+    const backend = params.resolveFilesystemBackend(params.binding);
+    if (hasSkills) {
+        middleware.push(createSkillsMiddleware({
+            backend,
+            sources: params.compatibleParams.skills,
+        }));
+    }
+    if (hasMemory) {
+        middleware.push(createMemoryMiddleware({
+            backend,
+            sources: params.compatibleParams.memory,
+        }));
+    }
+    return middleware;
+}
 export function resolveBuiltinMiddlewareBackend(input) {
     const runtimeState = {
         ...(input.options?.state ?? {}),
@@ -134,18 +156,11 @@ export async function resolveLangChainAutomaticMiddleware(input) {
     const automaticMiddleware = [];
     automaticMiddleware.push(createPatchToolCallsMiddleware());
     automaticMiddleware.push(...(await input.resolveAutomaticSummarizationMiddleware(input.binding)));
-    if ((compatibleParams.skills?.length ?? 0) > 0) {
-        automaticMiddleware.push(createSkillsMiddleware({
-            backend: input.resolveFilesystemBackend(input.binding),
-            sources: compatibleParams.skills,
-        }));
-    }
-    if ((compatibleParams.memory?.length ?? 0) > 0) {
-        automaticMiddleware.push(createMemoryMiddleware({
-            backend: input.resolveFilesystemBackend(input.binding),
-            sources: compatibleParams.memory,
-        }));
-    }
+    automaticMiddleware.push(...buildLangChainContextMiddleware({
+        binding: input.binding,
+        compatibleParams,
+        resolveFilesystemBackend: input.resolveFilesystemBackend,
+    }));
     if (hasConfiguredSubagentSupport(input.binding)) {
         automaticMiddleware.push(createSubAgentMiddleware({
             defaultModel: (await input.resolveModel(compatibleParams.model)),

package/dist/runtime/adapter/runnable-config.d.ts

@@ -0,0 +1,13 @@
+export type ResolvedRunnableDependencies = {
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+};
+export declare function buildResolvedRunnableConfig(params: {
+    passthrough?: Record<string, unknown>;
+    staticConfig?: Record<string, unknown>;
+    resolved: ResolvedRunnableDependencies;
+    extraConfig?: Record<string, unknown>;
+}): Record<string, unknown>;

package/dist/runtime/adapter/runnable-config.js

@@ -0,0 +1,13 @@
+export function buildResolvedRunnableConfig(params) {
+    const { passthrough, staticConfig, resolved, extraConfig } = params;
+    return {
+        ...(passthrough ?? {}),
+        ...(staticConfig ?? {}),
+        model: resolved.resolvedModel,
+        tools: resolved.resolvedTools,
+        middleware: resolved.resolvedMiddleware,
+        checkpointer: resolved.resolvedCheckpointer,
+        store: resolved.resolvedStore,
+        ...(extraConfig ?? {}),
+    };
+}

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

@@ -1,6 +1,6 @@
-import { getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryTools } from "../support/compiled-binding.js";
+import { getBindingExecutionView } from "../support/compiled-binding.js";
 export function countConfiguredTools(binding) {
-    return getBindingPrimaryTools(binding).length;
+    return getBindingExecutionView(binding).primaryTools.length;
 }
 export function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
@@ -9,14 +9,14 @@ export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export function hasConfiguredSubagentSupport(binding) {
-    const params = getBindingLangChainParams(binding);
+    const params = getBindingExecutionView(binding).langchainParams;
     if (!params) {
         return false;
     }
     return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
 }
 export function hasConfiguredMiddlewareKind(binding, kind) {
-    return getBindingMiddlewareConfigs(binding)?.some((entry) => entry.kind === kind) ?? false;
+    return getBindingExecutionView(binding).middlewareConfigs?.some((entry) => entry.kind === kind) ?? false;
 }
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

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

@@ -17,12 +17,13 @@ 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 { buildExecutableToolMap, resolveAdapterTools } from "./adapter/tool-resolution.js";
+import { resolveAdapterTools } from "./adapter/tool-resolution.js";
+import { buildBindingToolExecutionContext, resolveLangChainStreamContext } from "./adapter/execution-context.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, 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, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, 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,10 +36,17 @@ 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();
     runnableCache = new WeakMap();
+    toolNameMappingCache = new WeakMap();
     constructor(options = {}) {
         this.options = options;
     }
@@ -93,6 +101,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
@@ -188,7 +205,7 @@ export class AgentRuntimeAdapter {
     }
     async createLangChainRunnable(binding, options = {}) {
         const params = getBindingLangChainParams(binding);
-        const interruptOn = compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
+        const interruptOn = resolveBindingInterruptOn(binding);
         const model = (await this.resolveModel(params.model));
         const tools = this.resolveTools(params.tools, binding);
         if (tools.length > 0 && typeof model.bindTools !== "function") {
@@ -199,7 +216,7 @@ export class AgentRuntimeAdapter {
             resolvedModel: model,
             resolvedTools: tools,
             resolvedMiddleware: await this.resolveMiddleware(binding, interruptOn),
-            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
+            resolvedCheckpointer: resolveBindingCheckpointer(this.options, binding),
             resolvedStore: this.options.storeResolver?.(binding),
             passthroughOverride: options.passthroughOverride,
             systemPromptOverride: options.systemPromptOverride,
@@ -226,10 +243,10 @@ export class AgentRuntimeAdapter {
             resolvedTools: this.resolveTools(compatibleParams.tools, binding),
             resolvedMiddleware: await this.resolveMiddleware(binding),
             resolvedSubagents: await this.resolveSubagents(compatibleParams.subagents, binding),
-            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
+            resolvedCheckpointer: resolveBindingCheckpointer(this.options, binding),
             resolvedStore: this.options.storeResolver?.(binding),
             resolvedBackend: this.options.backendResolver?.(binding),
-            resolvedInterruptOn: compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding)),
+            resolvedInterruptOn: resolveBindingInterruptOn(binding),
             resolvedSkills: (await materializeDeepAgentSkillSourcePaths({
                 workspaceRoot: binding.harnessRuntime.workspaceRoot,
                 runRoot: binding.harnessRuntime.runRoot,
@@ -272,13 +289,10 @@ export class AgentRuntimeAdapter {
                 callRuntime,
             });
         };
-        const primaryTools = getBindingPrimaryTools(binding);
-        const resolvedTools = this.resolveTools(primaryTools, binding);
-        const toolNameMapping = buildToolNameMapping(primaryTools);
-        const executableTools = buildExecutableToolMap({
-            primaryTools,
-            resolvedTools,
-            toolNameMapping,
+        const { primaryTools, toolNameMapping, executableTools, defersToUpstreamHitlExecution, } = buildBindingToolExecutionContext({
+            binding,
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
             context: options.context,
         });
         const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
@@ -287,7 +301,7 @@ export class AgentRuntimeAdapter {
             request,
             resumePayload,
             primaryTools,
-            defersToUpstreamHitlExecution: primaryTools.some((tool) => tool.hitl?.enabled === true),
+            defersToUpstreamHitlExecution,
             toolNameMapping,
             executableTools,
             builtinExecutableTools: builtinExecutableTools,
@@ -310,24 +324,16 @@ export class AgentRuntimeAdapter {
         const invokeTimeoutMs = resolveBindingTimeout(binding);
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-        const primaryTools = getBindingPrimaryTools(binding);
-        const toolNameMapping = buildToolNameMapping(primaryTools);
-        const primaryModel = getBindingPrimaryModel(binding);
-        const forceInvokeFallback = isLangChainBinding(binding) &&
-            primaryTools.length > 0 &&
-            primaryModel?.provider === "openai-compatible";
-        const langchainParams = isLangChainBinding(binding) ? getBindingLangChainParams(binding) : undefined;
-        const resolvedLangChainModel = langchainParams
-            ? (await this.resolveModel(langchainParams.model))
-            : undefined;
-        const resolvedLangChainTools = langchainParams ? this.resolveTools(langchainParams.tools, binding) : [];
-        const canUseDirectModelStream = !!resolvedLangChainModel &&
-            (resolvedLangChainTools.length === 0 || typeof resolvedLangChainModel.bindTools !== "function");
-        const langChainStreamModel = resolvedLangChainModel && canUseDirectModelStream
-            ? resolvedLangChainModel
-            : resolvedLangChainModel && typeof resolvedLangChainModel.bindTools === "function" && resolvedLangChainTools.length > 0
-                ? resolvedLangChainModel.bindTools(resolvedLangChainTools)
-                : undefined;
+        const { primaryTools, toolNameMapping } = buildBindingToolExecutionContext({
+            binding,
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
+        });
+        const { forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveLangChainStreamContext({
+            binding,
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+        });
         yield* streamRuntimeExecution({
             binding,
             input,

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

@@ -0,0 +1,13 @@
+import type { HarnessEvent } from "../../contracts/types.js";
+import type { RuntimePersistence } from "../../persistence/types.js";
+export declare function createBackgroundEventRuntime(input: {
+    persistence: RuntimePersistence;
+    publishEvent: (event: HarnessEvent) => void;
+    trackBackgroundTask: (task: Promise<void>) => void;
+    backgroundEventTypes: ReadonlySet<HarnessEvent["eventType"]>;
+}): {
+    persistence: RuntimePersistence;
+    publishEvent: (event: HarnessEvent) => void;
+    trackBackgroundTask: (task: Promise<void>) => void;
+    backgroundEventTypes: ReadonlySet<import("../../contracts/runtime.js").HarnessEventType>;
+};

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

@@ -0,0 +1,8 @@
+export function createBackgroundEventRuntime(input) {
+    return {
+        persistence: input.persistence,
+        publishEvent: input.publishEvent,
+        trackBackgroundTask: input.trackBackgroundTask,
+        backgroundEventTypes: input.backgroundEventTypes,
+    };
+}

package/dist/runtime/harness/bindings.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledTool, RuntimeAdapterOptions, WorkspaceBundle } from "../../contracts/types.js";
+type Binding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
+export declare function getWorkspaceBinding(workspace: WorkspaceBundle, agentId: string): Binding | undefined;
+export declare function getRequiredWorkspaceBinding(workspace: WorkspaceBundle, agentId: string): Binding;
+export declare function resolveWorkspaceAgentTools(input: {
+    workspace: WorkspaceBundle;
+    agentId: string;
+    toolResolver?: RuntimeAdapterOptions["toolResolver"];
+}): Array<{
+    compiledTool: CompiledTool;
+    resolvedTool: unknown;
+}>;
+export declare function bindingSupportsRunningReplay(binding: Binding): boolean;
+export {};

package/dist/runtime/harness/bindings.js

@@ -0,0 +1,23 @@
+import { getBindingPrimaryTools } from "../support/compiled-binding.js";
+export function getWorkspaceBinding(workspace, agentId) {
+    return workspace.bindings.get(agentId);
+}
+export function getRequiredWorkspaceBinding(workspace, agentId) {
+    const binding = getWorkspaceBinding(workspace, agentId);
+    if (!binding) {
+        throw new Error(`Unknown agent ${agentId}`);
+    }
+    return binding;
+}
+export function resolveWorkspaceAgentTools(input) {
+    const binding = getRequiredWorkspaceBinding(input.workspace, input.agentId);
+    const compiledTools = getBindingPrimaryTools(binding);
+    const resolvedTools = input.toolResolver ? input.toolResolver(compiledTools.map((tool) => tool.id), binding) : [];
+    return compiledTools.map((compiledTool, index) => ({
+        compiledTool,
+        resolvedTool: resolvedTools[index],
+    }));
+}
+export function bindingSupportsRunningReplay(binding) {
+    return getBindingPrimaryTools(binding).every((tool) => tool.retryable === true);
+}

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.d.ts

@@ -14,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;
@@ -30,7 +33,7 @@ export declare class AgentHarnessRuntime {
     private pendingRunInsertionOrder;
     private readonly pendingRunSlots;
     private runtimeEventSequence;
-    private listHostBindings;
+    private readonly backgroundEventRuntime;
     private defaultRunRoot;
     private getDefaultHostAgentId;
     private resolveSelectedAgentId;
@@ -41,8 +44,6 @@ export declare class AgentHarnessRuntime {
     initialize(): Promise<void>;
     subscribe(listener: (event: HarnessEvent) => void): () => void;
     getHealth(): Promise<RuntimeHealthSnapshot>;
-    private resolveAgentTools;
-    private supportsRunningReplay;
     listThreads(filter?: {
         agentId?: string;
     }): Promise<ThreadSummary[]>;
@@ -89,7 +90,6 @@ export declare class AgentHarnessRuntime {
     private isDecisionRun;
     private notifyListener;
     private prepareRunStart;
-    private createStartupRecoveryContext;
     private acquireRunSlot;
     private dropPendingRunSlot;
     private dispatchRunListeners;

package/dist/runtime/harness.js

@@ -4,6 +4,7 @@ import { createPersistentId } from "../utils/id.js";
 import { AgentRuntimeAdapter } from "./agent-runtime-adapter.js";
 import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./harness/events/event-bus.js";
+import { createBackgroundEventRuntime } from "./harness/background-runtime.js";
 import { PolicyEngine } from "./harness/system/policy-engine.js";
 import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.js";
 import { createHarnessEvent, inferRoutingBindings, renderRuntimeFailure, } from "./support/harness-support.js";
@@ -22,7 +23,8 @@ import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-que
 import { getDefaultHostAgentId, resolveSelectedAgentId } from "./harness/run/routing.js";
 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 { getBindingAdapterKind, getBindingStoreConfig } from "./support/compiled-binding.js";
+import { getRequiredWorkspaceBinding, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
 import { initializeHarnessRuntime, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
@@ -46,6 +48,9 @@ export class AgentHarnessRuntime {
     stores = new Map();
     embeddingModels = new Map();
     vectorStores = new Map();
+    hostBindings;
+    defaultHostBinding;
+    defaultRunRootValue;
     defaultStore;
     runtimeMemoryStore;
     routingRules;
@@ -62,12 +67,9 @@ export class AgentHarnessRuntime {
     pendingRunInsertionOrder = 0;
     pendingRunSlots = [];
     runtimeEventSequence = 0;
-    listHostBindings() {
-        return inferRoutingBindings(this.workspace).hostBindings;
-    }
+    backgroundEventRuntime;
     defaultRunRoot() {
-        return (this.listHostBindings()[0]?.harnessRuntime.runRoot ??
-            `${this.workspace.workspaceRoot}/run-data`);
+        return this.defaultRunRootValue;
     }
     getDefaultHostAgentId() {
         return getDefaultHostAgentId(this.workspace, this.routingDefaultAgentId);
@@ -85,13 +87,16 @@ export class AgentHarnessRuntime {
     constructor(workspace, runtimeAdapterOptions = {}) {
         this.workspace = workspace;
         this.runtimeAdapterOptions = runtimeAdapterOptions;
+        this.hostBindings = inferRoutingBindings(this.workspace).hostBindings;
+        this.defaultHostBinding = this.hostBindings[0];
+        this.defaultRunRootValue = this.defaultHostBinding?.harnessRuntime.runRoot ?? `${this.workspace.workspaceRoot}/run-data`;
         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 = {
@@ -110,6 +115,12 @@ export class AgentHarnessRuntime {
                 ((binding) => createResourceBackendResolver(workspace)(binding)),
         };
         this.runtimeAdapter = new AgentRuntimeAdapter(this.resolvedRuntimeAdapterOptions);
+        this.backgroundEventRuntime = createBackgroundEventRuntime({
+            persistence: this.persistence,
+            publishEvent: (event) => this.eventBus.publish(event),
+            trackBackgroundTask: (task) => this.trackBackgroundTask(task),
+            backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+        });
         this.routingRules = getRoutingRules(workspace.refs);
         this.routingDefaultAgentId = getRoutingDefaultAgentId(workspace.refs);
         if (isThreadMemorySyncEnabled(workspace)) {
@@ -159,23 +170,6 @@ export class AgentHarnessRuntime {
         }
         return createDefaultHealthSnapshot(this.activeRunSlots, this.pendingRunSlots.length);
     }
-    resolveAgentTools(agentId) {
-        const binding = this.workspace.bindings.get(agentId);
-        if (!binding) {
-            throw new Error(`Unknown agent ${agentId}`);
-        }
-        const compiledTools = getBindingPrimaryTools(binding);
-        const resolver = this.resolvedRuntimeAdapterOptions.toolResolver;
-        const resolvedTools = resolver ? resolver(compiledTools.map((tool) => tool.id), binding) : [];
-        return compiledTools.map((compiledTool, index) => ({
-            compiledTool,
-            resolvedTool: resolvedTools[index],
-        }));
-    }
-    supportsRunningReplay(binding) {
-        const tools = getBindingPrimaryTools(binding);
-        return tools.every((tool) => tool.retryable === true);
-    }
     async listThreads(filter) {
         return this.persistence.listSessions(filter);
     }
@@ -242,7 +236,11 @@ export class AgentHarnessRuntime {
         }, threadId);
     }
     async createToolMcpServer(options) {
-        const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
+        const tools = resolveWorkspaceAgentTools({
+            workspace: this.workspace,
+            agentId: options.agentId,
+            toolResolver: this.resolvedRuntimeAdapterOptions.toolResolver,
+        }).map(({ compiledTool, resolvedTool }) => ({
             compiledTool,
             resolvedTool,
             sourceTool: this.workspace.tools.get(compiledTool.id),
@@ -250,7 +248,11 @@ export class AgentHarnessRuntime {
         return createToolMcpServerFromTools(tools, options);
     }
     async serveToolsOverStdio(options) {
-        const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
+        const tools = resolveWorkspaceAgentTools({
+            workspace: this.workspace,
+            agentId: options.agentId,
+            toolResolver: this.resolvedRuntimeAdapterOptions.toolResolver,
+        }).map(({ compiledTool, resolvedTool }) => ({
             compiledTool,
             resolvedTool,
             sourceTool: this.workspace.tools.get(compiledTool.id),
@@ -261,13 +263,13 @@ export class AgentHarnessRuntime {
         const rawInput = extractMessageText(input);
         const configuredRule = this.routingRules.find((rule) => matchRoutingRule(rawInput, rule, options));
         if (configuredRule) {
-            const configuredBinding = this.workspace.bindings.get(configuredRule.agentId);
+            const configuredBinding = getWorkspaceBinding(this.workspace, configuredRule.agentId);
             if (configuredBinding) {
                 return configuredBinding.agent.id;
             }
         }
         const defaultBinding = this.routingDefaultAgentId
-            ? this.workspace.bindings.get(this.routingDefaultAgentId)
+            ? getWorkspaceBinding(this.workspace, this.routingDefaultAgentId)
             : undefined;
         if (defaultBinding) {
             return defaultBinding.agent.id;
@@ -430,10 +432,7 @@ export class AgentHarnessRuntime {
         }
         catch (error) {
             await emitSyntheticFallbackEvent({
-                persistence: this.persistence,
-                publishEvent: (event) => this.eventBus.publish(event),
-                trackBackgroundTask: (task) => this.trackBackgroundTask(task),
-                backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+                ...this.backgroundEventRuntime,
             }, threadId, runId, agentId, error, 103);
             await this.setRunStateAndEmit(threadId, runId, 104, "failed", {
                 previousState: previousState === "queued" ? "running" : previousState,
@@ -461,18 +460,12 @@ export class AgentHarnessRuntime {
     }
     async setRunStateAndEmit(threadId, runId, sequence, state, options) {
         return setRunStateAndEmitEvent({
-            persistence: this.persistence,
-            publishEvent: (event) => this.eventBus.publish(event),
-            trackBackgroundTask: (task) => this.trackBackgroundTask(task),
-            backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+            ...this.backgroundEventRuntime,
         }, threadId, runId, sequence, state, options);
     }
     async requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence) {
         return requestApprovalAndEmitEvent({
-            persistence: this.persistence,
-            publishEvent: (event) => this.eventBus.publish(event),
-            trackBackgroundTask: (task) => this.trackBackgroundTask(task),
-            backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+            ...this.backgroundEventRuntime,
         }, threadId, runId, input, interruptContent, checkpointRef, sequence);
     }
     isDecisionRun(options) {
@@ -486,10 +479,7 @@ export class AgentHarnessRuntime {
     }
     async prepareRunStart(options, invocation, runCreatedPayload) {
         const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
-        const binding = this.workspace.bindings.get(selectedAgentId);
-        if (!binding) {
-            throw new Error(`Unknown agent ${selectedAgentId}`);
-        }
+        const binding = getRequiredWorkspaceBinding(this.workspace, selectedAgentId);
         const policyDecision = this.policyEngine.evaluate(binding);
         if (!policyDecision.allowed) {
             throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
@@ -505,34 +495,11 @@ export class AgentHarnessRuntime {
             runId,
             isNewThread,
             runCreatedEventPromise: emitRunCreatedEvent({
-                persistence: this.persistence,
-                publishEvent: (event) => this.eventBus.publish(event),
-                trackBackgroundTask: (task) => this.trackBackgroundTask(task),
-                backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+                ...this.backgroundEventRuntime,
             }, threadId, runId, runCreatedPayload(binding, selectedAgentId)),
             releaseRunSlotPromise: this.acquireRunSlot(threadId, runId, "running", priority),
         };
     }
-    createStartupRecoveryContext() {
-        return {
-            persistence: this.persistence,
-            workspace: this.workspace,
-            runtimeAdapter: this.runtimeAdapter,
-            recoveryConfig: this.recoveryConfig,
-            concurrencyConfig: this.concurrencyConfig,
-            getBinding: (agentId) => this.workspace.bindings.get(agentId),
-            acquireRunSlot: (threadId, runId, activeState = "running", priority = 0) => this.acquireRunSlot(threadId, runId, activeState, priority),
-            executeQueuedRun: (binding, input, threadId, runId, agentId, options = {}) => this.executeQueuedRun(binding, input, threadId, runId, agentId, options),
-            setRunStateAndEmit: (threadId, runId, sequence, state, options) => this.setRunStateAndEmit(threadId, runId, sequence, state, options),
-            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
-            loadRunInput: (threadId, runId) => this.loadRunInput(threadId, runId),
-            finalizeContinuedRun: (binding, threadId, runId, input, actual, options) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, options),
-            supportsRunningReplay: (binding) => this.supportsRunningReplay(binding),
-            isStaleRunningRun: (thread, nowMs = Date.now()) => this.isStaleRunningRun(thread, nowMs),
-            recordLlmSuccess: (startedAt) => this.recordLlmSuccess(startedAt),
-            recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
-        };
-    }
     async acquireRunSlot(threadId, runId, activeState = "running", priority = 0) {
         return acquireHarnessRunSlot({
             persistence: this.persistence,
@@ -604,7 +571,7 @@ export class AgentHarnessRuntime {
     async *streamEvents(options) {
         const invocation = normalizeInvocationEnvelope(options);
         const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
-        const binding = this.workspace.bindings.get(selectedAgentId);
+        const binding = getWorkspaceBinding(this.workspace, selectedAgentId);
         if (!binding) {
             const result = await this.run(options);
             for (const line of result.output.split("\n")) {
@@ -644,10 +611,7 @@ export class AgentHarnessRuntime {
             appendAssistantMessage: (currentThreadId, currentRunId, content) => appendLifecycleAssistantMessage(this.persistence, currentThreadId, currentRunId, content),
             clearRunRequest: (currentThreadId, currentRunId) => this.persistence.clearRunRequest(currentThreadId, currentRunId),
             emitSyntheticFallback: (currentThreadId, currentRunId, currentSelectedAgentId, error) => emitSyntheticFallbackEvent({
-                persistence: this.persistence,
-                publishEvent: (event) => this.eventBus.publish(event),
-                trackBackgroundTask: (task) => this.trackBackgroundTask(task),
-                backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+                ...this.backgroundEventRuntime,
             }, currentThreadId, currentRunId, currentSelectedAgentId, error),
         });
     }
@@ -656,7 +620,7 @@ export class AgentHarnessRuntime {
             getApprovalById: (approvalId) => this.persistence.getApproval(approvalId),
             getSession: (threadId) => this.getSession(threadId),
             resolveApprovalRecord: (resumeOptions, thread) => resolveHarnessApprovalRecord(this.persistence, resumeOptions, thread),
-            getBinding: (agentId) => this.workspace.bindings.get(agentId),
+            getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
             buildResumePayload: (binding, approval, resumeOptions) => buildHarnessResumePayload(binding, approval, resumeOptions),
             getRunCancellation: (runId) => this.getRunCancellation(runId),
             finalizeCancelledRun: (threadId, runId, previousState, reason) => this.finalizeCancelledRun(threadId, runId, previousState, reason),

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

@@ -1,4 +1,18 @@
 import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams, RuntimeModelSlot } from "../../contracts/types.js";
+export type BindingExecutionView = {
+    adapterKind: string;
+    adapterConfig: Record<string, unknown>;
+    langchainParams?: LangChainAgentParams;
+    deepAgentParams?: DeepAgentParams;
+    executionParams?: LangChainAgentParams | DeepAgentParams;
+    primaryTools: CompiledTool[];
+    primaryModel?: CompiledModel;
+    systemPrompt?: string;
+    middlewareConfigs?: Array<Record<string, unknown>>;
+    interruptCompatibilityRules?: Record<string, boolean | object>;
+    storeConfig?: Record<string, unknown>;
+};
+export declare function getBindingExecutionView(binding: CompiledAgentBinding): BindingExecutionView;
 export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
 export declare function getBindingAdapterConfig(binding: CompiledAgentBinding): Record<string, unknown>;
 export declare function getBindingLangChainParams(binding: CompiledAgentBinding): LangChainAgentParams | undefined;

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

@@ -3,25 +3,53 @@ 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,
+        executionParams: 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 getBindingExecutionView(binding) {
+    return deriveBindingExecutionView(binding);
+}
 export function getBindingAdapterKind(binding) {
-    return binding.adapter?.kind ?? binding.agent.executionMode;
+    return getBindingExecutionView(binding).adapterKind;
 }
 export function getBindingAdapterConfig(binding) {
-    return binding.adapter?.config ?? {};
+    return getBindingExecutionView(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 getBindingExecutionView(binding).langchainParams;
 }
 export function getBindingDeepAgentParams(binding) {
-    const adapterParams = asRecord(getBindingAdapterConfig(binding).params);
-    if (getBindingAdapterKind(binding) === "deepagent" && adapterParams) {
-        return adapterParams;
-    }
-    return binding.deepAgentParams;
+    return getBindingExecutionView(binding).deepAgentParams;
 }
 export function isLangChainBinding(binding) {
     return getBindingAdapterKind(binding) === "langchain-v1" || Boolean(binding.langchainAgentParams);
@@ -30,30 +58,29 @@ export function isDeepAgentBinding(binding) {
     return getBindingAdapterKind(binding) === "deepagent" || Boolean(binding.deepAgentParams);
 }
 export function getBindingPrimaryTools(binding) {
-    return binding.langchainAgentParams?.tools ?? binding.deepAgentParams?.tools ?? [];
+    return getBindingExecutionView(binding).primaryTools;
 }
 export function getBindingPrimaryModel(binding) {
-    return binding.langchainAgentParams?.model ?? binding.deepAgentParams?.model;
+    return getBindingExecutionView(binding).primaryModel;
 }
 export function getBindingRuntimeModel(binding, slot) {
     return binding.harnessRuntime.models?.[slot];
 }
 export function getBindingSystemPrompt(binding) {
-    return binding.langchainAgentParams?.systemPrompt ?? binding.deepAgentParams?.systemPrompt;
+    return getBindingExecutionView(binding).systemPrompt;
 }
 export function getBindingMiddlewareConfigs(binding) {
-    return binding.langchainAgentParams?.middleware ?? binding.deepAgentParams?.middleware;
+    return getBindingExecutionView(binding).middlewareConfigs;
 }
 export function getBindingInterruptCompatibilityRules(binding) {
-    return binding.deepAgentParams?.interruptOn ??
-        binding.agent.langchainAgentConfig?.interruptOn;
+    return getBindingExecutionView(binding).interruptCompatibilityRules;
 }
 export function getBindingModelInit(binding) {
     return getBindingPrimaryModel(binding)?.init;
 }
 export function getBindingStoreConfig(binding) {
-    return binding.deepAgentParams?.store ?? binding.harnessRuntime.store;
+    return getBindingExecutionView(binding).storeConfig;
 }
 export function bindingHasSubagents(binding) {
-    return (binding.deepAgentParams?.subagents.length ?? 0) > 0;
+    return (getBindingDeepAgentParams(binding)?.subagents.length ?? 0) > 0;
 }

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

@@ -90,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) {
@@ -124,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;
@@ -286,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);
@@ -323,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,
@@ -370,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.106",
+  "version": "0.0.108",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",