@botbotgo/agent-harness 0.0.115 → 0.0.116

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.114";
+export declare const AGENT_HARNESS_VERSION = "0.0.115";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.114";
+export const AGENT_HARNESS_VERSION = "0.0.115";

package/dist/runtime/adapter/middleware-assembly.d.ts

@@ -1,14 +1,21 @@
 import { FilesystemBackend } from "deepagents";
 import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, DeepAgentParams, RuntimeAdapterOptions } from "../../contracts/types.js";
 import type { ExecutableTool } from "./flow/invoke-runtime.js";
-export declare function buildBuiltinTaskSubagentRunnableConfig(input: {
-    selectedSubagent: CompiledSubAgent;
-    defaultModel: unknown;
-    defaultTools: unknown[];
-    middleware: unknown[];
-}): Record<string, unknown>;
+export type UpstreamSubagentConfig = {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    model?: unknown;
+    tools?: unknown[];
+    skills?: string[];
+    interruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    responseFormat?: unknown;
+    middleware?: unknown[];
+};
 export declare function buildBuiltinTaskSubagentMiddleware(input: {
-    selectedSubagent: CompiledSubAgent;
+    selectedSubagent: UpstreamSubagentConfig;
     builtinBackend: unknown;
     summarizationModel: unknown;
 }): unknown[];
@@ -27,7 +34,7 @@ export declare function resolveSubagents(input: {
     resolveModel: (model: CompiledModel) => Promise<unknown>;
     resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
     createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
-}): Promise<CompiledSubAgent[]>;
+}): Promise<UpstreamSubagentConfig[]>;
 export declare function invokeBuiltinTaskTool(input: {
     binding: CompiledAgentBinding;
     toolInput: unknown;
@@ -41,7 +48,7 @@ export declare function invokeBuiltinTaskTool(input: {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
     }) => unknown;
-    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<CompiledSubAgent[]>;
+    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<UpstreamSubagentConfig[]>;
     resolveModel: (model: CompiledModel) => Promise<unknown>;
     resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
 }): Promise<unknown>;
@@ -73,7 +80,7 @@ export declare function resolveLangChainAutomaticMiddleware(input: {
     resolveFilesystemBackend: (binding: CompiledAgentBinding) => FilesystemBackend;
     resolveModel: (model: CompiledModel) => Promise<unknown>;
     resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
-    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<CompiledSubAgent[]>;
+    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<UpstreamSubagentConfig[]>;
 }): Promise<unknown[]>;
 export declare function resolveMiddleware(input: {
     binding: CompiledAgentBinding;

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

@@ -8,18 +8,6 @@ import { isRecord } from "../../utils/object.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryModel, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
-export function buildBuiltinTaskSubagentRunnableConfig(input) {
-    const { selectedSubagent, defaultModel, defaultTools, middleware } = input;
-    return {
-        model: (selectedSubagent.model ?? defaultModel),
-        tools: (selectedSubagent.tools ?? defaultTools),
-        systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
-        middleware: middleware,
-        responseFormat: selectedSubagent.responseFormat,
-        name: selectedSubagent.name,
-        description: selectedSubagent.description,
-    };
-}
 export function buildBuiltinTaskSubagentMiddleware(input) {
     const { selectedSubagent, builtinBackend, summarizationModel } = input;
     const defaultSubagentMiddleware = [
@@ -35,7 +23,7 @@ export function buildBuiltinTaskSubagentMiddleware(input) {
     const subagentMiddleware = selectedSubagent.middleware ?? [];
     const interruptMiddleware = selectedSubagent.interruptOn
         ? [humanInTheLoopMiddleware({
-                interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
+                interruptOn: compileInterruptOn((selectedSubagent.tools ?? []), selectedSubagent.interruptOn),
             })]
         : [];
     return [
@@ -47,8 +35,8 @@ export function buildBuiltinTaskSubagentMiddleware(input) {
 }
 function buildLangChainContextMiddleware(params) {
     const middleware = [];
-    const hasSkills = (params.compatibleParams.skills?.length ?? 0) > 0;
-    const hasMemory = (params.compatibleParams.memory?.length ?? 0) > 0;
+    const hasSkills = (params.skills?.length ?? 0) > 0;
+    const hasMemory = (params.memory?.length ?? 0) > 0;
     if (!hasSkills && !hasMemory) {
         return middleware;
     }
@@ -56,17 +44,24 @@ function buildLangChainContextMiddleware(params) {
     if (hasSkills) {
         middleware.push(createSkillsMiddleware({
             backend,
-            sources: params.compatibleParams.skills,
+            sources: params.skills,
         }));
     }
     if (hasMemory) {
         middleware.push(createMemoryMiddleware({
             backend,
-            sources: params.compatibleParams.memory,
+            sources: params.memory,
         }));
     }
     return middleware;
 }
+function resolveLangChainDelegationCompatibility(params) {
+    return applyDeepAgentDelegationPromptCompatibility(params.model, {
+        subagents: params.subagents,
+        generalPurposeAgent: params.generalPurposeAgent,
+        taskDescription: params.taskDescription,
+    });
+}
 export function resolveBuiltinMiddlewareBackend(input) {
     const runtimeState = {
         ...(input.options?.state ?? {}),
@@ -127,20 +122,22 @@ export async function invokeBuiltinTaskTool(input) {
         const allowed = resolvedSubagents.map((subagent) => subagent.name);
         throw new Error(`Error: invoked agent of type ${subagentType}, the only allowed types are ${allowed.map((name) => `\`${name}\``).join(", ")}`);
     }
-    const summarizationModel = selectedSubagent.model
-        ? await input.resolveModel(selectedSubagent.model)
-        : await input.resolveModel(params.model);
+    const resolvedHostModel = selectedSubagent.model ? undefined : await input.resolveModel(params.model);
+    const summarizationModel = selectedSubagent.model ?? resolvedHostModel;
     const middleware = buildBuiltinTaskSubagentMiddleware({
         selectedSubagent,
         builtinBackend,
         summarizationModel,
     });
-    const runnable = createAgent(buildBuiltinTaskSubagentRunnableConfig({
-        selectedSubagent,
-        defaultModel: await input.resolveModel(params.model),
-        defaultTools: input.resolveTools(params.tools, input.binding),
-        middleware,
-    }));
+    const runnable = createAgent({
+        model: (selectedSubagent.model ?? resolvedHostModel),
+        tools: (selectedSubagent.tools ?? input.resolveTools(params.tools, input.binding)),
+        systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
+        middleware: middleware,
+        responseFormat: selectedSubagent.responseFormat,
+        name: selectedSubagent.name,
+        description: selectedSubagent.description,
+    });
     const result = await runnable.invoke({ messages: [new HumanMessage({ content: description })] }, { configurable: { thread_id: `${input.binding.agent.id}:builtin-task` }, ...(input.options?.context ? { context: input.options.context } : {}) });
     const visibleOutput = extractVisibleOutput(result);
     const fallbackOutput = extractToolFallbackContext(result);
@@ -170,23 +167,29 @@ export async function resolveLangChainAutomaticMiddleware(input) {
     if (!params) {
         return [];
     }
-    const compatibleParams = applyDeepAgentDelegationPromptCompatibility(params.model, params);
+    const delegationCompatibility = resolveLangChainDelegationCompatibility({
+        model: params.model,
+        subagents: params.subagents,
+        generalPurposeAgent: params.generalPurposeAgent,
+        taskDescription: params.taskDescription,
+    });
     const automaticMiddleware = [];
     automaticMiddleware.push(createPatchToolCallsMiddleware());
     automaticMiddleware.push(...(await input.resolveAutomaticSummarizationMiddleware(input.binding)));
     automaticMiddleware.push(...buildLangChainContextMiddleware({
         binding: input.binding,
-        compatibleParams,
+        skills: params.skills,
+        memory: params.memory,
         resolveFilesystemBackend: input.resolveFilesystemBackend,
     }));
     if (bindingHasLangChainSubagentSupport(input.binding)) {
         automaticMiddleware.push(createSubAgentMiddleware({
-            defaultModel: (await input.resolveModel(compatibleParams.model)),
-            defaultTools: input.resolveTools(compatibleParams.tools, input.binding),
+            defaultModel: (await input.resolveModel(params.model)),
+            defaultTools: input.resolveTools(params.tools, input.binding),
             defaultInterruptOn: getBindingInterruptCompatibilityRules(input.binding),
-            subagents: (await input.resolveSubagents(compatibleParams.subagents ?? [], input.binding)),
-            generalPurposeAgent: compatibleParams.generalPurposeAgent,
-            taskDescription: compatibleParams.taskDescription ?? null,
+            subagents: (await input.resolveSubagents(delegationCompatibility.subagents ?? [], input.binding)),
+            generalPurposeAgent: delegationCompatibility.generalPurposeAgent,
+            taskDescription: delegationCompatibility.taskDescription ?? null,
         }));
     }
     return automaticMiddleware;

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

@@ -1,6 +1,7 @@
 import type { CompiledAgentBinding, MessageContent, RunResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
+import { type UpstreamSubagentConfig } from "./adapter/middleware-assembly.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
@@ -11,6 +12,34 @@ type RunnableLike = {
     streamEvents?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
 };
 declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+export declare function resolveRunnableCheckpointer(options: RuntimeAdapterOptions, binding: CompiledAgentBinding): unknown;
+export declare function resolveRunnableInterruptOn(binding: CompiledAgentBinding): Record<string, {
+    allowedDecisions: import("./adapter/tool/interrupt-policy.js").InterruptDecision[];
+}> | undefined;
+export declare function buildLangChainCreateParams(input: {
+    binding: CompiledAgentBinding;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    passthroughOverride?: Record<string, unknown>;
+    systemPromptOverride?: string;
+}): Record<string, unknown>;
+export declare function buildDeepAgentCreateParams(input: {
+    binding: CompiledAgentBinding;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: UpstreamSubagentConfig[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    resolvedBackend: unknown;
+    resolvedInterruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    resolvedSkills: string[];
+}): Record<string, unknown>;
 export declare class AgentRuntimeAdapter {
     private readonly options;
     private readonly modelCache;

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

@@ -1,23 +1,24 @@
 import path from "node:path";
+import { MemorySaver } from "@langchain/langgraph";
 import { createDeepAgent, FilesystemBackend, } from "deepagents";
 import { createAgent } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { assembleDeepAgentRunnable, assembleLangChainRunnable, } from "./adapter/flow/runnable-assembly.js";
+import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRuntimeInvocation } from "./adapter/flow/invocation-flow.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
-import { buildDeepAgentRunnableConfig, buildLangChainRunnableConfig } from "./adapter/runnable-config.js";
 import { applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
 import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, resolveAutomaticSummarizationMiddleware as resolveAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainAutomaticMiddleware as resolveLangChainAutomaticMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
 import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
+import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingAdapterKind, getBindingLangChainParams, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "write_todos",
@@ -30,6 +31,56 @@ const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "execute",
     "task",
 ]);
+export function resolveRunnableCheckpointer(options, binding) {
+    return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
+}
+export function resolveRunnableInterruptOn(binding) {
+    return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
+}
+export function buildLangChainCreateParams(input) {
+    const langchainParams = getBindingLangChainParams(input.binding);
+    if (!langchainParams) {
+        throw new Error(`Agent ${input.binding.agent.id} has no langchain params`);
+    }
+    return {
+        ...(input.passthroughOverride ?? langchainParams.passthrough ?? {}),
+        systemPrompt: input.systemPromptOverride ?? langchainParams.systemPrompt,
+        stateSchema: langchainParams.stateSchema,
+        responseFormat: langchainParams.responseFormat,
+        contextSchema: langchainParams.contextSchema,
+        includeAgentName: langchainParams.includeAgentName,
+        version: langchainParams.version,
+        name: langchainParams.name,
+        description: langchainParams.description,
+        model: input.resolvedModel,
+        tools: input.resolvedTools,
+        middleware: input.resolvedMiddleware,
+        checkpointer: input.resolvedCheckpointer,
+        store: input.resolvedStore,
+    };
+}
+export function buildDeepAgentCreateParams(input) {
+    const deepAgentParams = getBindingDeepAgentParams(input.binding);
+    if (!deepAgentParams) {
+        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
+    }
+    return {
+        systemPrompt: deepAgentParams.systemPrompt,
+        responseFormat: deepAgentParams.responseFormat,
+        contextSchema: deepAgentParams.contextSchema,
+        name: deepAgentParams.name,
+        memory: deepAgentParams.memory,
+        skills: input.resolvedSkills,
+        model: input.resolvedModel,
+        tools: input.resolvedTools,
+        middleware: input.resolvedMiddleware,
+        checkpointer: input.resolvedCheckpointer,
+        store: input.resolvedStore,
+        subagents: input.resolvedSubagents,
+        backend: input.resolvedBackend,
+        interruptOn: input.resolvedInterruptOn,
+    };
+}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -211,29 +262,29 @@ export class AgentRuntimeAdapter {
         });
     }
     async createLangChainRunnable(binding, options = {}) {
-        const assembly = await assembleLangChainRunnable({
+        const langchainParams = getBindingLangChainParams(binding);
+        if (!langchainParams) {
+            throw new Error(`Agent ${binding.agent.id} has no langchain params`);
+        }
+        const interruptOn = resolveRunnableInterruptOn(binding);
+        const resolvedModel = await this.resolveModel(langchainParams.model);
+        const resolvedTools = this.resolveTools(langchainParams.tools, binding);
+        const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn);
+        const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
+        const resolvedStore = this.options.storeResolver?.(binding);
+        const model = resolvedModel;
+        if (resolvedTools.length > 0 && typeof model.bindTools !== "function") {
+            throw new Error(`Agent ${binding.agent.id} configures ${resolvedTools.length} tool(s), but resolved model ${langchainParams.model.id} does not support tool binding.`);
+        }
+        return createAgent(buildLangChainCreateParams({
             binding,
-            runtimeAdapterOptions: this.options,
-            resolveModel: (model) => this.resolveModel(model),
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
-            resolveMiddleware: (currentBinding, interruptOn) => this.resolveMiddleware(currentBinding, interruptOn),
+            resolvedModel: model,
+            resolvedTools,
+            resolvedMiddleware,
+            resolvedCheckpointer,
+            resolvedStore,
             passthroughOverride: options.passthroughOverride,
             systemPromptOverride: options.systemPromptOverride,
-        });
-        const model = assembly.resolvedModel;
-        const tools = assembly.resolvedTools;
-        if (tools.length > 0 && typeof model.bindTools !== "function") {
-            throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${assembly.langchainParams.model.id} does not support tool binding.`);
-        }
-        return createAgent(buildLangChainRunnableConfig({
-            langchainParams: assembly.langchainParams,
-            resolvedModel: model,
-            resolvedTools: tools,
-            resolvedMiddleware: assembly.resolvedMiddleware,
-            resolvedCheckpointer: assembly.resolvedCheckpointer,
-            resolvedStore: assembly.resolvedStore,
-            passthroughOverride: assembly.passthroughOverride,
-            systemPromptOverride: assembly.systemPromptOverride,
         }));
     }
     async createRunnable(binding) {
@@ -246,25 +297,35 @@ export class AgentRuntimeAdapter {
         return this.createDeepAgentRunnable(binding);
     }
     async createDeepAgentRunnable(binding) {
-        const assembly = await assembleDeepAgentRunnable({
+        const deepAgentParams = getBindingDeepAgentParams(binding);
+        if (!deepAgentParams) {
+            throw new Error(`Agent ${binding.agent.id} has no runnable params`);
+        }
+        const resolvedModel = await this.resolveModel(deepAgentParams.model);
+        const resolvedTools = this.resolveTools(deepAgentParams.tools, binding);
+        const resolvedMiddleware = await this.resolveMiddleware(binding);
+        const resolvedSubagents = await this.resolveSubagents(deepAgentParams.subagents, binding);
+        const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
+        const resolvedStore = this.options.storeResolver?.(binding);
+        const resolvedBackend = this.options.backendResolver?.(binding);
+        const resolvedInterruptOn = resolveRunnableInterruptOn(binding);
+        const resolvedSkills = resolveDeepAgentSkillSourcePaths({
+            workspaceRoot: binding.harnessRuntime.workspaceRoot,
+            runRoot: binding.harnessRuntime.runRoot,
+            ownerId: binding.agent.id,
+            skillPaths: deepAgentParams.skills,
+        }) ?? [];
+        const deepAgentConfig = buildDeepAgentCreateParams({
             binding,
-            runtimeAdapterOptions: this.options,
-            resolveModel: (model) => this.resolveModel(model),
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
-            resolveMiddleware: (currentBinding, interruptOn) => this.resolveMiddleware(currentBinding, interruptOn),
-            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
-        });
-        const deepAgentConfig = buildDeepAgentRunnableConfig({
-            compatibleParams: assembly.compatibleParams,
-            resolvedModel: assembly.resolvedModel,
-            resolvedTools: assembly.resolvedTools,
-            resolvedMiddleware: assembly.resolvedMiddleware,
-            resolvedSubagents: assembly.resolvedSubagents,
-            resolvedCheckpointer: assembly.resolvedCheckpointer,
-            resolvedStore: assembly.resolvedStore,
-            resolvedBackend: assembly.resolvedBackend,
-            resolvedInterruptOn: assembly.resolvedInterruptOn,
-            resolvedSkills: assembly.resolvedSkills,
+            resolvedModel,
+            resolvedTools,
+            resolvedMiddleware,
+            resolvedSubagents,
+            resolvedCheckpointer,
+            resolvedStore,
+            resolvedBackend,
+            resolvedInterruptOn,
+            resolvedSkills,
         });
         return createDeepAgent(deepAgentConfig);
     }

package/package.json

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

package/dist/runtime/adapter/flow/runnable-assembly.d.ts

@@ -1,51 +0,0 @@
-import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LangChainAgentParams, RuntimeAdapterOptions } from "../../../contracts/types.js";
-export declare function resolveRunnableCheckpointer(options: RuntimeAdapterOptions, binding: CompiledAgentBinding): unknown;
-export declare function resolveRunnableInterruptOn(binding: CompiledAgentBinding): Record<string, {
-    allowedDecisions: import("../tool/interrupt-policy.js").InterruptDecision[];
-}> | undefined;
-export declare function assembleLangChainRunnable(input: {
-    binding: CompiledAgentBinding;
-    runtimeAdapterOptions: RuntimeAdapterOptions;
-    passthroughOverride?: Record<string, unknown>;
-    systemPromptOverride?: string;
-    resolveModel: (model: CompiledModel) => Promise<unknown>;
-    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
-    resolveMiddleware: (binding: CompiledAgentBinding, interruptOn?: Record<string, {
-        allowedDecisions: Array<"approve" | "edit" | "reject">;
-    }>) => Promise<unknown[]>;
-}): Promise<{
-    langchainParams: LangChainAgentParams;
-    interruptOn?: Record<string, {
-        allowedDecisions: Array<"approve" | "edit" | "reject">;
-    }>;
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedCheckpointer: unknown;
-    resolvedStore: unknown;
-    passthroughOverride?: Record<string, unknown>;
-    systemPromptOverride?: string;
-}>;
-export declare function assembleDeepAgentRunnable(input: {
-    binding: CompiledAgentBinding;
-    runtimeAdapterOptions: RuntimeAdapterOptions;
-    resolveModel: (model: CompiledModel) => Promise<unknown>;
-    resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
-    resolveMiddleware: (binding: CompiledAgentBinding, interruptOn?: Record<string, {
-        allowedDecisions: Array<"approve" | "edit" | "reject">;
-    }>) => Promise<unknown[]>;
-    resolveSubagents: (subagents: CompiledSubAgent[], binding?: CompiledAgentBinding) => Promise<CompiledSubAgent[]>;
-}): Promise<{
-    compatibleParams: DeepAgentParams;
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedSubagents: CompiledSubAgent[];
-    resolvedCheckpointer: unknown;
-    resolvedStore: unknown;
-    resolvedBackend: unknown;
-    resolvedInterruptOn?: Record<string, {
-        allowedDecisions: Array<"approve" | "edit" | "reject">;
-    }>;
-    resolvedSkills: string[];
-}>;

package/dist/runtime/adapter/flow/runnable-assembly.js

@@ -1,52 +0,0 @@
-import { MemorySaver } from "@langchain/langgraph";
-import { applyDeepAgentDelegationPromptCompatibility, resolveDeepAgentSkillSourcePaths, } from "../compat/deepagent-compat.js";
-import { compileInterruptOn } from "../tool/interrupt-policy.js";
-import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingPrimaryTools, } from "../../support/compiled-binding.js";
-export function resolveRunnableCheckpointer(options, binding) {
-    return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
-}
-export function resolveRunnableInterruptOn(binding) {
-    return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
-}
-export async function assembleLangChainRunnable(input) {
-    const langchainParams = getBindingLangChainParams(input.binding);
-    if (!langchainParams) {
-        throw new Error(`Agent ${input.binding.agent.id} has no langchain params`);
-    }
-    const interruptOn = resolveRunnableInterruptOn(input.binding);
-    return {
-        langchainParams,
-        interruptOn,
-        resolvedModel: await input.resolveModel(langchainParams.model),
-        resolvedTools: input.resolveTools(langchainParams.tools, input.binding),
-        resolvedMiddleware: await input.resolveMiddleware(input.binding, interruptOn),
-        resolvedCheckpointer: resolveRunnableCheckpointer(input.runtimeAdapterOptions, input.binding),
-        resolvedStore: input.runtimeAdapterOptions.storeResolver?.(input.binding),
-        passthroughOverride: input.passthroughOverride,
-        systemPromptOverride: input.systemPromptOverride,
-    };
-}
-export async function assembleDeepAgentRunnable(input) {
-    const deepAgentParams = getBindingDeepAgentParams(input.binding);
-    if (!deepAgentParams) {
-        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
-    }
-    const compatibleParams = applyDeepAgentDelegationPromptCompatibility(deepAgentParams.model, deepAgentParams);
-    return {
-        compatibleParams,
-        resolvedModel: await input.resolveModel(compatibleParams.model),
-        resolvedTools: input.resolveTools(compatibleParams.tools, input.binding),
-        resolvedMiddleware: await input.resolveMiddleware(input.binding),
-        resolvedSubagents: await input.resolveSubagents(compatibleParams.subagents, input.binding),
-        resolvedCheckpointer: resolveRunnableCheckpointer(input.runtimeAdapterOptions, input.binding),
-        resolvedStore: input.runtimeAdapterOptions.storeResolver?.(input.binding),
-        resolvedBackend: input.runtimeAdapterOptions.backendResolver?.(input.binding),
-        resolvedInterruptOn: resolveRunnableInterruptOn(input.binding),
-        resolvedSkills: resolveDeepAgentSkillSourcePaths({
-            workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
-            runRoot: input.binding.harnessRuntime.runRoot,
-            ownerId: input.binding.agent.id,
-            skillPaths: compatibleParams.skills,
-        }) ?? [],
-    };
-}

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

@@ -1,54 +0,0 @@
-export type ResolvedRunnableDependencies = {
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedCheckpointer: unknown;
-    resolvedStore: unknown;
-};
-type LangChainRunnableConfigParams = {
-    langchainParams: {
-        passthrough?: Record<string, unknown>;
-        systemPrompt?: string;
-        stateSchema?: unknown;
-        responseFormat?: unknown;
-        contextSchema?: unknown;
-        includeAgentName?: unknown;
-        version?: unknown;
-        name?: unknown;
-        description?: unknown;
-    };
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedCheckpointer: unknown;
-    resolvedStore: unknown;
-    passthroughOverride?: Record<string, unknown>;
-    systemPromptOverride?: string;
-};
-type DeepAgentRunnableConfigParams = {
-    compatibleParams: {
-        systemPrompt?: string;
-        responseFormat?: unknown;
-        contextSchema?: unknown;
-        name?: unknown;
-        memory?: unknown;
-    };
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedSubagents: unknown[];
-    resolvedCheckpointer: unknown;
-    resolvedStore: unknown;
-    resolvedBackend: unknown;
-    resolvedInterruptOn: unknown;
-    resolvedSkills: string[];
-};
-export declare function buildResolvedRunnableConfig(params: {
-    passthrough?: Record<string, unknown>;
-    staticConfig?: Record<string, unknown>;
-    resolved: ResolvedRunnableDependencies;
-    extraConfig?: Record<string, unknown>;
-}): Record<string, unknown>;
-export declare function buildLangChainRunnableConfig(params: LangChainRunnableConfigParams): Record<string, unknown>;
-export declare function buildDeepAgentRunnableConfig(params: DeepAgentRunnableConfigParams): Record<string, unknown>;
-export {};

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

@@ -1,61 +0,0 @@
-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 ?? {}),
-    };
-}
-export function buildLangChainRunnableConfig(params) {
-    const { langchainParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedCheckpointer, resolvedStore, passthroughOverride, systemPromptOverride, } = params;
-    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,
-            resolvedTools,
-            resolvedMiddleware,
-            resolvedCheckpointer,
-            resolvedStore,
-        },
-    });
-}
-export function buildDeepAgentRunnableConfig(params) {
-    const { compatibleParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedSubagents, resolvedCheckpointer, resolvedStore, resolvedBackend, resolvedInterruptOn, resolvedSkills, } = params;
-    return buildResolvedRunnableConfig({
-        staticConfig: {
-            systemPrompt: compatibleParams.systemPrompt,
-            responseFormat: compatibleParams.responseFormat,
-            contextSchema: compatibleParams.contextSchema,
-            name: compatibleParams.name,
-            memory: compatibleParams.memory,
-            skills: resolvedSkills,
-        },
-        resolved: {
-            resolvedModel,
-            resolvedTools,
-            resolvedMiddleware,
-            resolvedCheckpointer,
-            resolvedStore,
-        },
-        extraConfig: {
-            subagents: resolvedSubagents,
-            backend: resolvedBackend,
-            interruptOn: resolvedInterruptOn,
-        },
-    });
-}