@botbotgo/agent-harness 0.0.100 → 0.0.101

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.99";
+export declare const AGENT_HARNESS_VERSION = "0.0.100";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.99";
+export const AGENT_HARNESS_VERSION = "0.0.100";

package/dist/resource/resource-impl.js

@@ -81,13 +81,14 @@ function listProviderTools(provider) {
         toolPath: tool.toolPath ?? tool.builtinPath ?? "",
     }));
 }
+function preferProviderValue(provider, primary, fallback) {
+    return provider ? (primary(provider) ?? fallback(provider)) : undefined;
+}
 function createProviderToolResolver(provider, workspace, options) {
-    return (provider?.createResourceToolResolver?.(workspace, options) ??
-        provider?.createBuiltinToolResolver?.(workspace, options));
+    return preferProviderValue(provider, (candidate) => candidate.createResourceToolResolver?.(workspace, options), (candidate) => candidate.createBuiltinToolResolver?.(workspace, options));
 }
 function createProviderBackendResolver(provider, workspace) {
-    return (provider?.createResourceBackendResolver?.(workspace) ??
-        provider?.createBuiltinBackendResolver?.(workspace));
+    return preferProviderValue(provider, (candidate) => candidate.createResourceBackendResolver?.(workspace), (candidate) => candidate.createBuiltinBackendResolver?.(workspace));
 }
 class CompatibleCompositeBackend {
     id;
@@ -133,69 +134,66 @@ class CompatibleCompositeBackend {
         return this.composite.downloadFiles(paths);
     }
 }
+const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.';
+function unsupportedInlineBackend(kind) {
+    throw new Error(INLINE_BACKEND_ERROR.replace("%s", kind));
+}
+function resolveInlineBackendRootDir(workspaceRoot, configuredRootDir) {
+    if (typeof configuredRootDir === "string" && configuredRootDir.trim().length > 0) {
+        return path.isAbsolute(configuredRootDir)
+            ? configuredRootDir
+            : path.resolve(workspaceRoot, configuredRootDir);
+    }
+    return workspaceRoot;
+}
+function createLocalShellStyleBackend(workspaceRoot, config, options) {
+    const rootDir = resolveInlineBackendRootDir(workspaceRoot, config?.rootDir);
+    mkdirSync(rootDir, { recursive: true });
+    const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
+    return new LocalShellBackend({
+        rootDir,
+        virtualMode: options.virtualMode,
+        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
+        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
+        env: createRuntimeEnv(readStringRecord(config?.env), inheritedEnv),
+        inheritEnv: config?.inheritEnv !== false,
+    });
+}
+function createInlineBackendInstance(workspaceRoot, kind, config, runtimeLike) {
+    switch (kind) {
+        case "LocalShellBackend":
+            return createLocalShellStyleBackend(workspaceRoot, config, {
+                virtualMode: config?.virtualMode === true,
+            });
+        case "VfsSandbox":
+            return createLocalShellStyleBackend(workspaceRoot, config, {
+                virtualMode: config?.virtualMode === false ? false : true,
+            });
+        case "StateBackend":
+            return new StateBackend(runtimeLike);
+        case "StoreBackend":
+            return new StoreBackend(runtimeLike);
+        default:
+            return unsupportedInlineBackend(kind);
+    }
+}
 function createInlineBackendResolver(workspace) {
     return (binding) => {
         const backendConfig = binding.deepAgentParams?.backend;
         if (!backendConfig || typeof backendConfig !== "object") {
             return undefined;
         }
-        const resolveBackendRootDir = (configuredRootDir) => {
-            if (typeof configuredRootDir === "string" && configuredRootDir.trim().length > 0) {
-                return path.isAbsolute(configuredRootDir)
-                    ? configuredRootDir
-                    : path.resolve(workspace.workspaceRoot, configuredRootDir);
-            }
-            return workspace.workspaceRoot;
-        };
-        const createBackend = (kind, config, runtimeLike) => {
-            const configuredEnv = typeof config?.env === "object" && config.env
-                ? Object.fromEntries(Object.entries(config.env).filter((entry) => typeof entry[1] === "string"))
-                : undefined;
-            const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
-            switch (kind) {
-                case "LocalShellBackend": {
-                    const rootDir = resolveBackendRootDir(config?.rootDir);
-                    mkdirSync(rootDir, { recursive: true });
-                    return new LocalShellBackend({
-                        rootDir,
-                        virtualMode: config?.virtualMode === true,
-                        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
-                        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
-                        env: createRuntimeEnv(configuredEnv, inheritedEnv),
-                        inheritEnv: config?.inheritEnv !== false,
-                    });
-                }
-                case "VfsSandbox": {
-                    const rootDir = resolveBackendRootDir(config?.rootDir);
-                    mkdirSync(rootDir, { recursive: true });
-                    return new LocalShellBackend({
-                        rootDir,
-                        virtualMode: config?.virtualMode === false ? false : true,
-                        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
-                        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
-                        env: createRuntimeEnv(configuredEnv, inheritedEnv),
-                        inheritEnv: config?.inheritEnv !== false,
-                    });
-                }
-                case "StateBackend":
-                    return new StateBackend(runtimeLike);
-                case "StoreBackend":
-                    return new StoreBackend(runtimeLike);
-                default:
-                    throw new Error(`Unsupported DeepAgent backend kind "${kind}". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.`);
-            }
-        };
         return (runtimeLike) => {
             const kind = typeof backendConfig.kind === "string" ? backendConfig.kind : "CompositeBackend";
             switch (kind) {
                 case "LocalShellBackend":
-                    return createBackend("LocalShellBackend", backendConfig, runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "LocalShellBackend", backendConfig, runtimeLike);
                 case "VfsSandbox":
-                    return createBackend("VfsSandbox", backendConfig, runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "VfsSandbox", backendConfig, runtimeLike);
                 case "StateBackend":
-                    return new StateBackend(runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "StateBackend", backendConfig, runtimeLike);
                 case "StoreBackend":
-                    return new StoreBackend(runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "StoreBackend", backendConfig, runtimeLike);
                 case "CompositeBackend": {
                     const stateConfig = typeof backendConfig.state === "object" && backendConfig.state
                         ? backendConfig.state
@@ -206,12 +204,12 @@ function createInlineBackendResolver(workspace) {
                         : { "/memories/": { kind: "StoreBackend" } };
                     const mappedRoutes = Object.fromEntries(Object.entries(routes).map(([route, routeConfig]) => {
                         const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
-                        return [route, createBackend(routeKind, routeConfig, runtimeLike)];
+                        return [route, createInlineBackendInstance(workspace.workspaceRoot, routeKind, routeConfig, runtimeLike)];
                     }));
-                    return new CompatibleCompositeBackend(createBackend(defaultBackendKind, stateConfig, runtimeLike), mappedRoutes);
+                    return new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes);
                 }
                 default:
-                    throw new Error(`Unsupported DeepAgent backend kind "${kind}". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.`);
+                    return unsupportedInlineBackend(kind);
             }
         };
     };
@@ -240,6 +238,23 @@ async function findPackageRoot(startPath) {
 }
 const functionToolModuleCache = new Map();
 const mcpClientCache = new Map();
+function readStringRecord(value) {
+    if (typeof value !== "object" || !value) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function listWorkspaceResourceProviders(workspace) {
+    return (workspace.resourceSources ?? [])
+        .map((source) => remoteResourceCache.get(source))
+        .filter((provider) => Boolean(provider));
+}
+function createWorkspaceProviderResolvers(workspace, factory) {
+    return listWorkspaceResourceProviders(workspace)
+        .map((provider) => factory(provider))
+        .filter((resolver) => Boolean(resolver));
+}
 async function loadFunctionToolModule(tool) {
     const cacheKey = `${tool.sourcePath}:${tool.implementationName ?? tool.id}`;
     const cached = functionToolModuleCache.get(cacheKey);
@@ -294,20 +309,15 @@ function readMcpServerConfig(workspace, tool) {
     if (!mcpServer) {
         return null;
     }
-    const envRecord = typeof mcpServer.env === "object" && mcpServer.env
-        ? Object.fromEntries(Object.entries(mcpServer.env).filter((entry) => typeof entry[1] === "string"))
-        : undefined;
     return {
         transport: normalizeMcpTransport(mcpServer.transport) ?? ((typeof mcpServer.url === "string" && mcpServer.url.trim()) ? "http" : "stdio"),
         command: typeof mcpServer.command === "string" ? mcpServer.command.trim() : undefined,
         args: Array.isArray(mcpServer.args) ? mcpServer.args.filter((item) => typeof item === "string") : undefined,
-        env: envRecord,
+        env: readStringRecord(mcpServer.env),
         cwd: typeof mcpServer.cwd === "string" ? mcpServer.cwd : undefined,
         url: typeof mcpServer.url === "string" ? mcpServer.url.trim() : undefined,
         token: typeof mcpServer.token === "string" ? mcpServer.token : undefined,
-        headers: typeof mcpServer.headers === "object" && mcpServer.headers
-            ? Object.fromEntries(Object.entries(mcpServer.headers).filter((entry) => typeof entry[1] === "string"))
-            : undefined,
+        headers: readStringRecord(mcpServer.headers),
     };
 }
 function createMcpCacheKey(config) {
@@ -514,11 +524,11 @@ export async function ensureResourceSources(sources = [], workspaceRoot = proces
 }
 export function defaultResourceSkillsRoot() {
     const provider = requireLocalResource("default resource skill resolution");
-    return provider.defaultResourceSkillsRoot?.() ?? provider.builtinSkillsRoot?.() ?? "";
+    return preferProviderValue(provider, (candidate) => candidate.defaultResourceSkillsRoot?.(), (candidate) => candidate.builtinSkillsRoot?.()) ?? "";
 }
 export function defaultResourceConfigRoot() {
     const provider = requireLocalResource("default resource config resolution");
-    return provider.defaultResourceConfigRoot?.() ?? provider.builtinConfigRoot?.() ?? provider.builtinDefaultsRoot?.() ?? "";
+    return (preferProviderValue(provider, (candidate) => candidate.defaultResourceConfigRoot?.(), (candidate) => candidate.builtinConfigRoot?.() ?? candidate.builtinDefaultsRoot?.()) ?? "");
 }
 export async function listResourceTools(sources = [], workspaceRoot = process.cwd()) {
     await ensureResourceSources(sources, workspaceRoot);
@@ -539,11 +549,7 @@ export async function listResourceToolsForSource(source, workspaceRoot = process
 }
 export function createResourceBackendResolver(workspace) {
     const localResolver = createProviderBackendResolver(localResource, workspace);
-    const remoteResolvers = (workspace.resourceSources ?? [])
-        .map((source) => remoteResourceCache.get(source))
-        .filter((provider) => Boolean(provider))
-        .map((provider) => createProviderBackendResolver(provider, workspace))
-        .filter((resolver) => Boolean(resolver));
+    const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderBackendResolver(provider, workspace));
     const inlineResolver = createInlineBackendResolver(workspace);
     return (binding) => {
         const providerResolved = localResolver?.(binding) ??
@@ -555,11 +561,7 @@ export function createResourceToolResolver(workspace, options = {}) {
     const functionResolver = createFunctionToolResolver(workspace);
     const mcpResolver = createMcpToolResolver(workspace);
     const localResolver = createProviderToolResolver(localResource, workspace, options);
-    const remoteResolvers = (workspace.resourceSources ?? [])
-        .map((source) => remoteResourceCache.get(source))
-        .filter((provider) => Boolean(provider))
-        .map((provider) => createProviderToolResolver(provider, workspace, options))
-        .filter((resolver) => Boolean(resolver));
+    const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderToolResolver(provider, workspace, options));
     return (toolIds, binding) => {
         const resolved = [
             ...functionResolver(toolIds, binding),

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

@@ -29,28 +29,17 @@ export declare class AgentRuntimeAdapter {
     private createModelFallbackRunnable;
     private applyStrictToolJsonInstruction;
     private resolveModel;
-    private buildToolNameMapping;
-    private buildSlashCommandSkillInstruction;
-    private buildInvocationRequest;
-    private buildRawModelMessages;
     private resolveTools;
-    private compileInterruptOn;
-    private resolveInterruptOn;
     private resolveFilesystemBackend;
     private resolveBuiltinMiddlewareBackend;
+    private createDeclaredMiddlewareResolverOptions;
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
     private resolveAutomaticSummarizationMiddleware;
     private resolveLangChainAutomaticMiddleware;
-    private resolveDeepAgentAutomaticMiddleware;
     private resolveMiddleware;
-    private resolveCheckpointer;
     private resolveSubagents;
     private createLangChainRunnable;
-    private extractInvocationRequestText;
-    private prependSystemMessage;
-    private replaceLastUserMessage;
-    private extractExecutedToolResults;
     private createRunnable;
     private createDeepAgentRunnable;
     create(binding: CompiledAgentBinding): Promise<RunnableLike>;

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

@@ -7,7 +7,6 @@ import { extractToolFallbackContext, extractVisibleOutput, isToolCallParseFailur
 import { readStreamDelta, } from "./parsing/stream-event-parsing.js";
 import { wrapToolForExecution } from "./adapter/tool/tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./adapter/tool/declared-middleware.js";
-import { extractMessageText } from "../utils/message-content.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { createBuiltinMiddlewareTools } from "./adapter/tool/builtin-middleware-tools.js";
@@ -19,12 +18,12 @@ import { buildDeepAgentRunnableConfig } from "./adapter/deepagent-runnable-confi
 import { buildLangChainRunnableConfig } from "./adapter/langchain-runnable-config.js";
 import { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
-import { buildInvocationRequest, buildSlashCommandSkillInstruction, } from "./adapter/model/invocation-request.js";
+import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
 import { buildRawModelMessages } from "./adapter/model/message-assembly.js";
 import { asStructuredExecutableTool, hasCallableToolHandler, normalizeResolvedToolSchema, wrapResolvedToolWithModelFacingName, } from "./adapter/tool/resolved-tool.js";
 import { instantiateProviderTool } from "./adapter/tool/provider-tool.js";
-import { asObject, countConfiguredTools, hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord, sleep, } from "./adapter/runtime-adapter-support.js";
+import { countConfiguredTools, hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord, sleep, } from "./adapter/runtime-adapter-support.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";
@@ -227,21 +226,9 @@ export class AgentRuntimeAdapter {
             throw error;
         }
     }
-    buildToolNameMapping(tools) {
-        return buildToolNameMapping(tools);
-    }
-    buildSlashCommandSkillInstruction(binding, input) {
-        return buildSlashCommandSkillInstruction(binding, input);
-    }
-    buildInvocationRequest(binding, history, input, options = {}) {
-        return buildInvocationRequest(binding, history, input, options);
-    }
-    buildRawModelMessages(binding, systemPrompt, history, input) {
-        return buildRawModelMessages(binding, systemPrompt, history, input);
-    }
     resolveTools(tools, binding) {
         const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
-        const toolNameMapping = this.buildToolNameMapping(tools);
+        const toolNameMapping = buildToolNameMapping(tools);
         return tools.flatMap((compiledTool, index) => {
             const resolvedTool = resolved[index] ?? (compiledTool.type === "provider" ? instantiateProviderTool(compiledTool) : undefined);
             if (resolvedTool === undefined) {
@@ -256,12 +243,6 @@ export class AgentRuntimeAdapter {
             return modelFacingName === compiledTool.name ? wrappedTool : wrapResolvedToolWithModelFacingName(wrappedTool, modelFacingName);
         });
     }
-    compileInterruptOn(tools, compatibilityRules) {
-        return compileInterruptOn(tools, compatibilityRules);
-    }
-    resolveInterruptOn(binding) {
-        return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
-    }
     resolveFilesystemBackend(binding) {
         const filesystemConfig = getBindingLangChainParams(binding)?.filesystem;
         const configuredRootDir = typeof filesystemConfig?.rootDir === "string" && filesystemConfig.rootDir.trim().length > 0
@@ -299,6 +280,21 @@ export class AgentRuntimeAdapter {
         }
         return new StateBackend(runtimeLike);
     }
+    createDeclaredMiddlewareResolverOptions(binding) {
+        return {
+            resolveModel: (model) => this.resolveModel(model),
+            resolveBackend: (resolvedBinding) => {
+                const targetBinding = resolvedBinding ?? binding;
+                return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
+            },
+            resolveFilesystemBackend: (resolvedBinding) => {
+                const targetBinding = resolvedBinding ?? binding;
+                return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
+            },
+            resolveCustom: this.options.declaredMiddlewareResolver,
+            binding,
+        };
+    }
     async invokeBuiltinTaskTool(binding, input, options = {}) {
         if (!isDeepAgentBinding(binding)) {
             throw new Error("The built-in task tool is only available for deepagent bindings.");
@@ -340,7 +336,7 @@ export class AgentRuntimeAdapter {
                 ]),
             ...(selectedSubagent.interruptOn
                 ? [humanInTheLoopMiddleware({
-                        interruptOn: this.compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
+                        interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
                     })]
                 : []),
         ];
@@ -376,13 +372,7 @@ export class AgentRuntimeAdapter {
         if (!primaryModel) {
             return [];
         }
-        return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], {
-            resolveModel: (model) => this.resolveModel(model),
-            resolveBackend: (resolvedBinding) => this.options.backendResolver?.(resolvedBinding ?? binding),
-            resolveFilesystemBackend: (resolvedBinding) => this.resolveFilesystemBackend(resolvedBinding ?? binding),
-            resolveCustom: this.options.declaredMiddlewareResolver,
-            binding,
-        });
+        return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], this.createDeclaredMiddlewareResolverOptions(binding));
     }
     async resolveLangChainAutomaticMiddleware(binding) {
         const params = getBindingLangChainParams(binding);
@@ -417,23 +407,11 @@ export class AgentRuntimeAdapter {
         }
         return automaticMiddleware;
     }
-    async resolveDeepAgentAutomaticMiddleware(binding) {
-        if (!isDeepAgentBinding(binding)) {
-            return [];
-        }
-        return [];
-    }
     async resolveMiddleware(binding, interruptOn) {
-        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
-            resolveModel: (model) => this.resolveModel(model),
-            resolveBackend: (resolvedBinding) => this.options.backendResolver?.(resolvedBinding ?? binding),
-            resolveFilesystemBackend: (resolvedBinding) => this.resolveFilesystemBackend(resolvedBinding ?? binding),
-            resolveCustom: this.options.declaredMiddlewareResolver,
-            binding,
-        });
+        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), this.createDeclaredMiddlewareResolverOptions(binding));
         const automaticMiddleware = isLangChainBinding(binding)
             ? await this.resolveLangChainAutomaticMiddleware(binding)
-            : await this.resolveDeepAgentAutomaticMiddleware(binding);
+            : [];
         const middleware = [
             ...declarativeMiddleware,
             ...automaticMiddleware,
@@ -444,9 +422,6 @@ export class AgentRuntimeAdapter {
         }
         return middleware;
     }
-    resolveCheckpointer(binding) {
-        return this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver();
-    }
     async resolveSubagents(subagents, binding) {
         return Promise.all(subagents.map(async (subagent) => ({
             ...subagent,
@@ -459,27 +434,15 @@ export class AgentRuntimeAdapter {
                 ownerId: `${binding?.agent.id ?? "agent"}-${subagent.name}`,
                 skillPaths: subagent.skills,
             }),
-            interruptOn: this.compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
+            interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
             responseFormat: subagent.responseFormat,
             contextSchema: subagent.contextSchema,
-            middleware: (await resolveDeclaredMiddleware(subagent.middleware, {
-                resolveModel: (model) => this.resolveModel(model),
-                resolveBackend: (resolvedBinding) => {
-                    const targetBinding = resolvedBinding ?? binding;
-                    return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
-                },
-                resolveFilesystemBackend: (resolvedBinding) => {
-                    const targetBinding = resolvedBinding ?? binding;
-                    return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
-                },
-                resolveCustom: this.options.declaredMiddlewareResolver,
-                binding,
-            })),
+            middleware: (await resolveDeclaredMiddleware(subagent.middleware, this.createDeclaredMiddlewareResolverOptions(binding))),
         })));
     }
     async createLangChainRunnable(binding, options = {}) {
         const params = getBindingLangChainParams(binding);
-        const interruptOn = this.resolveInterruptOn(binding);
+        const interruptOn = compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
         const model = (await this.resolveModel(params.model));
         const tools = this.resolveTools(params.tools, binding);
         if (tools.length > 0 && typeof model.bindTools !== "function") {
@@ -490,90 +453,12 @@ export class AgentRuntimeAdapter {
             resolvedModel: model,
             resolvedTools: tools,
             resolvedMiddleware: await this.resolveMiddleware(binding, interruptOn),
-            resolvedCheckpointer: this.resolveCheckpointer(binding),
+            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
             resolvedStore: this.options.storeResolver?.(binding),
             passthroughOverride: options.passthroughOverride,
             systemPromptOverride: options.systemPromptOverride,
         }));
     }
-    extractInvocationRequestText(request) {
-        if (!isRecord(request) || !Array.isArray(request.messages)) {
-            return "";
-        }
-        for (let index = request.messages.length - 1; index >= 0; index -= 1) {
-            const message = request.messages[index];
-            if (!isRecord(message)) {
-                continue;
-            }
-            const role = typeof message.role === "string" ? message.role : undefined;
-            if (role !== "user") {
-                continue;
-            }
-            return extractMessageText(message.content);
-        }
-        return "";
-    }
-    prependSystemMessage(request, content) {
-        if (!content.trim() || !isRecord(request) || !Array.isArray(request.messages)) {
-            return request;
-        }
-        return {
-            ...request,
-            messages: [{ role: "system", content }, ...request.messages],
-        };
-    }
-    replaceLastUserMessage(request, content) {
-        if (!content.trim() || !isRecord(request) || !Array.isArray(request.messages)) {
-            return request;
-        }
-        const messages = [...request.messages];
-        for (let index = messages.length - 1; index >= 0; index -= 1) {
-            const message = messages[index];
-            if (!isRecord(message) || message.role !== "user") {
-                continue;
-            }
-            messages[index] = {
-                ...message,
-                content,
-            };
-            return {
-                ...request,
-                messages,
-            };
-        }
-        return {
-            ...request,
-            messages: [...messages, { role: "user", content }],
-        };
-    }
-    extractExecutedToolResults(result) {
-        const metadata = asObject(result?.metadata);
-        if (Array.isArray(metadata?.executedToolResults)) {
-            return metadata.executedToolResults;
-        }
-        const messages = Array.isArray(result?.messages) ? result.messages : [];
-        return messages.flatMap((message) => {
-            const typed = asObject(message);
-            const kwargs = asObject(typed?.kwargs);
-            const typeId = Array.isArray(typed?.id) ? typed.id.at(-1) : undefined;
-            const runtimeType = typeof typed?.type === "string" ? typed.type : undefined;
-            if (typeId !== "ToolMessage" && runtimeType !== "tool") {
-                return [];
-            }
-            const toolName = typeof typed?.name === "string"
-                ? typed.name
-                : typeof kwargs?.name === "string"
-                    ? kwargs.name
-                    : "tool";
-            const output = typed?.content ??
-                kwargs?.content ??
-                "";
-            return [{
-                    toolName,
-                    output,
-                }];
-        });
-    }
     async createRunnable(binding) {
         if (getBindingAdapterKind(binding) === "langgraph") {
             throw new Error(`Agent ${binding.agent.id} uses removed backend langgraph; use langchain-v1 or deepagent`);
@@ -595,10 +480,10 @@ export class AgentRuntimeAdapter {
             resolvedTools: this.resolveTools(compatibleParams.tools, binding),
             resolvedMiddleware: await this.resolveMiddleware(binding),
             resolvedSubagents: await this.resolveSubagents(compatibleParams.subagents, binding),
-            resolvedCheckpointer: this.resolveCheckpointer(binding),
+            resolvedCheckpointer: this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver(),
             resolvedStore: this.options.storeResolver?.(binding),
             resolvedBackend: this.options.backendResolver?.(binding),
-            resolvedInterruptOn: this.resolveInterruptOn(binding),
+            resolvedInterruptOn: compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding)),
             resolvedSkills: (await materializeDeepAgentSkillSourcePaths({
                 workspaceRoot: binding.harnessRuntime.workspaceRoot,
                 runRoot: binding.harnessRuntime.runRoot,
@@ -625,7 +510,7 @@ export class AgentRuntimeAdapter {
     }
     async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
         const request = resumePayload === undefined
-            ? this.buildInvocationRequest(binding, history, input, options)
+            ? buildInvocationRequest(binding, history, input, options)
             : new Command({ resume: resumePayload });
         let result;
         const callRuntime = async (activeBinding, activeRequest) => {
@@ -657,7 +542,7 @@ export class AgentRuntimeAdapter {
             }
             else {
                 const resolvedTools = this.resolveTools(primaryTools, binding);
-                const toolNameMapping = this.buildToolNameMapping(primaryTools);
+                const toolNameMapping = buildToolNameMapping(primaryTools);
                 const executableTools = new Map();
                 const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
                 for (let index = 0; index < primaryTools.length; index += 1) {
@@ -720,7 +605,7 @@ export class AgentRuntimeAdapter {
             const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
             const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
             const primaryTools = getBindingPrimaryTools(binding);
-            const toolNameMapping = this.buildToolNameMapping(primaryTools);
+            const toolNameMapping = buildToolNameMapping(primaryTools);
             const primaryModel = getBindingPrimaryModel(binding);
             const forceInvokeFallback = isLangChainBinding(binding) &&
                 primaryTools.length > 0 &&
@@ -738,7 +623,7 @@ export class AgentRuntimeAdapter {
                 // For tool-using langchain agents, a raw model.stream pass cannot execute the
                 // agent loop and only adds an extra model round-trip before the runnable path.
                 if (canUseDirectModelStream && typeof model.stream === "function") {
-                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(binding, getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
+                    const stream = await this.withTimeout(() => model.stream(buildRawModelMessages(binding, getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
                     let emitted = false;
                     const projected = projectTextStreamChunks(this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, invokeTimeoutMs));
                     let nextChunk = await projected.next();
@@ -755,7 +640,7 @@ export class AgentRuntimeAdapter {
                 }
             }
             const runnable = await this.create(binding);
-            const request = this.buildInvocationRequest(binding, history, input, options);
+            const request = buildInvocationRequest(binding, history, input, options);
             if (!forceInvokeFallback && typeof runnable.streamEvents === "function") {
                 const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId, run_id: options.runId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
                 const projectionState = createStreamEventProjectionState();

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

@@ -0,0 +1,42 @@
+import type { MessageContent, RunResult, ThreadSummary, WorkspaceBundle } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+import type { AgentRuntimeAdapter } from "../../agent-runtime-adapter.js";
+import type { ConcurrencyConfig, RecoveryConfig } from "../../../workspace/support/workspace-ref-utils.js";
+type RecoveryBinding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
+type StartupRecoveryContext = {
+    persistence: RuntimePersistence;
+    workspace: WorkspaceBundle;
+    runtimeAdapter: AgentRuntimeAdapter;
+    recoveryConfig: RecoveryConfig;
+    concurrencyConfig: ConcurrencyConfig;
+    getBinding: (agentId: string) => RecoveryBinding | undefined;
+    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
+    executeQueuedRun: (binding: RecoveryBinding, input: MessageContent, threadId: string, runId: string, agentId: string, options?: {
+        context?: Record<string, unknown>;
+        state?: Record<string, unknown>;
+        files?: Record<string, unknown>;
+        previousState?: RunResult["state"];
+        stateSequence?: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+        previousState: string | null;
+        checkpointRef?: string | null;
+        error?: string;
+    }) => Promise<unknown>;
+    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    loadRunInput: (threadId: string, runId: string) => Promise<MessageContent>;
+    finalizeContinuedRun: (binding: RecoveryBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
+        previousState: RunResult["state"] | null;
+        stateSequence: number;
+        approvalSequence?: number;
+    }) => Promise<RunResult>;
+    supportsRunningReplay: (binding: RecoveryBinding) => boolean;
+    isStaleRunningRun: (thread: ThreadSummary, nowMs?: number) => Promise<boolean>;
+    recordLlmSuccess: (startedAt: number) => void;
+    recordLlmFailure: (startedAt: number) => void;
+};
+export declare function recoverQueuedStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export declare function recoverRunningStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export declare function recoverResumingStartupRun(context: StartupRecoveryContext, thread: ThreadSummary): Promise<boolean>;
+export {};