@botbotgo/agent-harness 0.0.102 → 0.0.104

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

@@ -1,32 +1,28 @@
 import path from "node:path";
 import { Command, MemorySaver } from "@langchain/langgraph";
-import { HumanMessage } from "@langchain/core/messages";
-import { DEFAULT_SUBAGENT_PROMPT, createDeepAgent, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
-import { createAgent, humanInTheLoopMiddleware } from "langchain";
-import { extractToolFallbackContext, extractVisibleOutput, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, wrapResolvedModel, } from "./parsing/output-parsing.js";
-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 { createDeepAgent, FilesystemBackend, } from "deepagents";
+import { createAgent } from "langchain";
+import { wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
-import { createBuiltinMiddlewareTools } from "./adapter/tool/builtin-middleware-tools.js";
 import { finalizeInvocationResult } from "./adapter/invocation-result.js";
 import { invokeRuntimeWithLocalTools } from "./adapter/invoke-runtime.js";
 import { streamRuntimeExecution } from "./adapter/stream-runtime.js";
 import { buildDeepAgentRunnableConfig } from "./adapter/deepagent-runnable-config.js";
 import { buildLangChainRunnableConfig } from "./adapter/langchain-runnable-config.js";
-import { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
+import { applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
+import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, resolveAutomaticSummarizationMiddleware as resolveAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainAutomaticMiddleware as resolveLangChainAutomaticMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
+import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
-import { asStructuredExecutableTool, hasCallableToolHandler, normalizeResolvedToolSchema, wrapResolvedToolWithModelFacingName, } from "./adapter/tool/resolved-tool.js";
-import { instantiateProviderTool } from "./adapter/tool/provider-tool.js";
-import { countConfiguredTools, hasConfiguredMiddlewareKind, hasConfiguredSubagentSupport, isObject, isRecord, sleep, } from "./adapter/runtime-adapter-support.js";
+import { countConfiguredTools, } from "./adapter/runtime-adapter-support.js";
+import { buildExecutableToolMap, resolveAdapterTools } from "./adapter/tool-resolution.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, getBindingMiddlewareConfigs, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingPrimaryModel, 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",
@@ -39,18 +35,6 @@ const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "execute",
     "task",
 ]);
-class RuntimeOperationTimeoutError extends Error {
-    operation;
-    timeoutMs;
-    stage;
-    constructor(operation, timeoutMs, stage = operation.includes("stream") ? "stream" : "invoke") {
-        super(`${operation} timed out after ${timeoutMs}ms`);
-        this.operation = operation;
-        this.timeoutMs = timeoutMs;
-        this.stage = stage;
-        this.name = "RuntimeOperationTimeoutError";
-    }
-}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -67,144 +51,22 @@ export class AgentRuntimeAdapter {
         });
     }
     async invokeWithProviderRetry(binding, operation) {
-        const retryPolicy = resolveProviderRetryPolicy(binding);
-        let lastError;
-        for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt += 1) {
-            try {
-                return await operation();
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt >= retryPolicy.maxAttempts || !isRetryableProviderError(binding, error)) {
-                    throw error;
-                }
-                if (retryPolicy.backoffMs > 0) {
-                    await sleep(retryPolicy.backoffMs);
-                }
-            }
-        }
-        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+        return invokeWithProviderRetryHelper(binding, operation);
     }
     async withTimeout(producer, timeoutMs, operation, stage = operation.includes("stream") ? "stream" : "invoke") {
-        if (!timeoutMs) {
-            return Promise.resolve(producer());
-        }
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => reject(new RuntimeOperationTimeoutError(operation, timeoutMs, stage)), timeoutMs);
-            Promise.resolve(producer()).then((value) => {
-                clearTimeout(timer);
-                resolve(value);
-            }, (error) => {
-                clearTimeout(timer);
-                reject(error);
-            });
-        });
+        return withRuntimeTimeout(producer, timeoutMs, operation, stage);
     }
     async *iterateWithTimeout(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs) {
-        const iterator = iterable[Symbol.asyncIterator]();
-        try {
-            for (;;) {
-                const effectiveTimeoutMs = computeRemainingTimeoutMs(deadlineAt, timeoutMs);
-                if (effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0) {
-                    throw new RuntimeOperationTimeoutError(operation, deadlineTimeoutMs ?? timeoutMs ?? 0, "invoke");
-                }
-                let next;
-                try {
-                    next = await this.withTimeout(() => iterator.next(), effectiveTimeoutMs, operation, "stream");
-                }
-                catch (error) {
-                    if (error instanceof RuntimeOperationTimeoutError &&
-                        deadlineAt &&
-                        deadlineTimeoutMs &&
-                        effectiveTimeoutMs !== timeoutMs) {
-                        throw new RuntimeOperationTimeoutError(operation, deadlineTimeoutMs, "invoke");
-                    }
-                    throw error;
-                }
-                if (next.done) {
-                    return;
-                }
-                yield next.value;
-            }
-        }
-        finally {
-            if (typeof iterator.return === "function") {
-                const returnResult = iterator.return();
-                if (returnResult && typeof returnResult.then === "function") {
-                    void returnResult.catch(() => undefined);
-                }
-            }
-        }
+        yield* iterateWithTimeoutHelper(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs);
     }
     async materializeModelStream(streamFactory, input, config) {
-        const stream = await streamFactory(input, config);
-        let content = "";
-        for await (const chunk of stream) {
-            const delta = readStreamDelta(chunk) || extractVisibleOutput(chunk);
-            if (delta) {
-                content += delta;
-            }
-        }
-        return { content };
+        return materializeModelStreamHelper(streamFactory, input, config);
     }
     createModelFallbackRunnable(model) {
-        return {
-            invoke: async (input, config) => {
-                const request = typeof input === "object" && input !== null && "messages" in input
-                    ? input.messages
-                    : input;
-                if (typeof model.invoke === "function") {
-                    return model.invoke(request, config);
-                }
-                if (typeof model.stream === "function") {
-                    return this.materializeModelStream(model.stream.bind(model), request, config);
-                }
-                throw new Error("Resolved model must define invoke or stream.");
-            },
-            stream: async (input, config) => {
-                if (typeof model.stream === "function") {
-                    const request = typeof input === "object" && input !== null && "messages" in input
-                        ? input.messages
-                        : input;
-                    return model.stream(request, config);
-                }
-                if (typeof model.invoke === "function") {
-                    const request = typeof input === "object" && input !== null && "messages" in input
-                        ? input.messages
-                        : input;
-                    const result = await model.invoke(request, config);
-                    const text = extractVisibleOutput(result);
-                    async function* singleChunk() {
-                        yield { content: text };
-                    }
-                    return singleChunk();
-                }
-                throw new Error("Resolved model must define invoke or stream.");
-            },
-        };
+        return createModelFallbackRunnableHelper(model);
     }
     applyStrictToolJsonInstruction(binding) {
-        if (isLangChainBinding(binding)) {
-            const params = getBindingLangChainParams(binding);
-            return {
-                ...binding,
-                langchainAgentParams: {
-                    ...params,
-                    systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
-                },
-            };
-        }
-        if (isDeepAgentBinding(binding)) {
-            const params = getBindingDeepAgentParams(binding);
-            return {
-                ...binding,
-                deepAgentParams: {
-                    ...params,
-                    systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
-                },
-            };
-        }
-        return binding;
+        return applyStrictToolJsonInstructionHelper(binding);
     }
     async resolveModel(model) {
         const cacheKey = this.getModelCacheKey(model);
@@ -225,20 +87,10 @@ export class AgentRuntimeAdapter {
         }
     }
     resolveTools(tools, binding) {
-        const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
-        const toolNameMapping = buildToolNameMapping(tools);
-        return tools.flatMap((compiledTool, index) => {
-            const resolvedTool = resolved[index] ?? (compiledTool.type === "provider" ? instantiateProviderTool(compiledTool) : undefined);
-            if (resolvedTool === undefined) {
-                return [];
-            }
-            const wrappedTool = wrapToolForExecution(resolvedTool, compiledTool, binding);
-            const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
-            const structuredTool = asStructuredExecutableTool(wrappedTool, modelFacingName, compiledTool.description);
-            if (structuredTool !== wrappedTool) {
-                return structuredTool;
-            }
-            return modelFacingName === compiledTool.name ? wrappedTool : wrapResolvedToolWithModelFacingName(wrappedTool, modelFacingName);
+        return resolveAdapterTools({
+            tools,
+            binding,
+            resolveToolValues: this.options.toolResolver,
         });
     }
     resolveFilesystemBackend(binding) {
@@ -259,24 +111,12 @@ export class AgentRuntimeAdapter {
         });
     }
     resolveBuiltinMiddlewareBackend(binding, options = {}) {
-        const runtimeState = {
-            ...(options.state ?? {}),
-            ...(isRecord(options.files) ? { files: options.files } : {}),
-        };
-        const runtimeLike = {
-            state: runtimeState,
-            store: this.options.storeResolver?.(binding),
-        };
-        const configuredBackend = isDeepAgentBinding(binding)
-            ? this.options.backendResolver?.(binding)
-            : this.resolveFilesystemBackend(binding);
-        if (typeof configuredBackend === "function") {
-            return configuredBackend(runtimeLike);
-        }
-        if (configuredBackend) {
-            return configuredBackend;
-        }
-        return new StateBackend(runtimeLike);
+        return resolveBuiltinMiddlewareBackendHelper({
+            binding,
+            runtimeAdapterOptions: this.options,
+            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
+            options,
+        });
     }
     createDeclaredMiddlewareResolverOptions(binding) {
         return {
@@ -294,149 +134,57 @@ export class AgentRuntimeAdapter {
         };
     }
     async invokeBuiltinTaskTool(binding, input, options = {}) {
-        if (!isDeepAgentBinding(binding)) {
-            throw new Error("The built-in task tool is only available for deepagent bindings.");
-        }
-        const params = getBindingDeepAgentParams(binding);
-        if (!params) {
-            throw new Error(`Agent ${binding.agent.id} has no deepagent params`);
-        }
-        const typedInput = isObject(input) ? input : {};
-        const description = typeof typedInput.description === "string" ? typedInput.description : "";
-        const subagentType = typeof typedInput.subagent_type === "string" ? typedInput.subagent_type : "";
-        const builtinBackend = this.resolveBuiltinMiddlewareBackend(binding, options);
-        const resolvedSubagents = await this.resolveSubagents(params.subagents, binding);
-        const selectedSubagent = resolvedSubagents.find((subagent) => subagent.name === subagentType);
-        if (!selectedSubagent) {
-            const allowed = [
-                ...resolvedSubagents.map((subagent) => subagent.name),
-                ...(params.generalPurposeAgent ? ["general-purpose"] : []),
-            ];
-            throw new Error(`Error: invoked agent of type ${subagentType}, the only allowed types are ${allowed.map((name) => `\`${name}\``).join(", ")}`);
-        }
-        const summarizationModel = selectedSubagent.model
-            ? await this.resolveModel(selectedSubagent.model)
-            : await this.resolveModel(params.model);
-        const middleware = [
-            ...(selectedSubagent.skills?.length
-                ? [createSkillsMiddleware({ backend: builtinBackend, sources: selectedSubagent.skills })]
-                : []),
-            ...(selectedSubagent.memory?.length
-                ? [createMemoryMiddleware({ backend: builtinBackend, sources: selectedSubagent.memory })]
-                : []),
-            ...(selectedSubagent.middleware ??
-                [
-                    createPatchToolCallsMiddleware(),
-                    createSummarizationMiddleware({
-                        model: summarizationModel,
-                        backend: builtinBackend,
-                    }),
-                ]),
-            ...(selectedSubagent.interruptOn
-                ? [humanInTheLoopMiddleware({
-                        interruptOn: compileInterruptOn(selectedSubagent.tools ?? [], selectedSubagent.interruptOn),
-                    })]
-                : []),
-        ];
-        const runnable = createAgent({
-            model: (selectedSubagent.model ?? (await this.resolveModel(params.model))),
-            tools: (selectedSubagent.tools ?? this.resolveTools(params.tools, binding)),
-            systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
-            middleware: middleware,
-            responseFormat: selectedSubagent.responseFormat,
-            contextSchema: selectedSubagent.contextSchema,
-            name: selectedSubagent.name,
-            description: selectedSubagent.description,
+        return invokeBuiltinTaskToolHelper({
+            binding,
+            toolInput: input,
+            options,
+            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
+            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
         });
-        const result = await runnable.invoke({ messages: [new HumanMessage({ content: description })] }, { configurable: { thread_id: `${binding.agent.id}:builtin-task` }, ...(options.context ? { context: options.context } : {}) });
-        const visibleOutput = extractVisibleOutput(result);
-        const fallbackOutput = extractToolFallbackContext(result);
-        return visibleOutput || fallbackOutput || JSON.stringify(result);
     }
     async resolveBuiltinMiddlewareTools(binding, options = {}) {
-        const backend = this.resolveBuiltinMiddlewareBackend(binding, options);
-        return createBuiltinMiddlewareTools(backend, {
-            includeTaskTool: isDeepAgentBinding(binding),
-            invokeTaskTool: isDeepAgentBinding(binding)
-                ? async (input) => this.invokeBuiltinTaskTool(binding, input, options)
-                : undefined,
+        return resolveBuiltinMiddlewareToolsHelper({
+            binding,
+            options,
+            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
+            invokeBuiltinTaskTool: (currentBinding, toolInput, currentOptions) => this.invokeBuiltinTaskTool(currentBinding, toolInput, currentOptions),
         });
     }
     async resolveAutomaticSummarizationMiddleware(binding) {
-        if (hasConfiguredMiddlewareKind(binding, "summarization")) {
-            return [];
-        }
-        const primaryModel = getBindingPrimaryModel(binding);
-        if (!primaryModel) {
-            return [];
-        }
-        return resolveDeclaredMiddleware([{ kind: "summarization", model: primaryModel }], this.createDeclaredMiddlewareResolverOptions(binding));
+        return resolveAutomaticSummarizationMiddlewareHelper({
+            binding,
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+        });
     }
     async resolveLangChainAutomaticMiddleware(binding) {
-        const params = getBindingLangChainParams(binding);
-        if (!params) {
-            return [];
-        }
-        const compatibleParams = applyDeepAgentDelegationPromptCompatibility(params.model, params);
-        const automaticMiddleware = [];
-        automaticMiddleware.push(createPatchToolCallsMiddleware());
-        automaticMiddleware.push(...(await this.resolveAutomaticSummarizationMiddleware(binding)));
-        if ((compatibleParams.skills?.length ?? 0) > 0) {
-            automaticMiddleware.push(createSkillsMiddleware({
-                backend: this.resolveFilesystemBackend(binding),
-                sources: compatibleParams.skills,
-            }));
-        }
-        if ((compatibleParams.memory?.length ?? 0) > 0) {
-            automaticMiddleware.push(createMemoryMiddleware({
-                backend: this.resolveFilesystemBackend(binding),
-                sources: compatibleParams.memory,
-            }));
-        }
-        if (hasConfiguredSubagentSupport(binding)) {
-            automaticMiddleware.push(createSubAgentMiddleware({
-                defaultModel: (await this.resolveModel(compatibleParams.model)),
-                defaultTools: this.resolveTools(compatibleParams.tools, binding),
-                defaultInterruptOn: getBindingInterruptCompatibilityRules(binding),
-                subagents: (await this.resolveSubagents(compatibleParams.subagents ?? [], binding)),
-                generalPurposeAgent: compatibleParams.generalPurposeAgent,
-                taskDescription: compatibleParams.taskDescription ?? null,
-            }));
-        }
-        return automaticMiddleware;
+        return resolveLangChainAutomaticMiddlewareHelper({
+            binding,
+            resolveAutomaticSummarizationMiddleware: (currentBinding) => this.resolveAutomaticSummarizationMiddleware(currentBinding),
+            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+        });
     }
     async resolveMiddleware(binding, interruptOn) {
-        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), this.createDeclaredMiddlewareResolverOptions(binding));
-        const automaticMiddleware = isLangChainBinding(binding)
-            ? await this.resolveLangChainAutomaticMiddleware(binding)
-            : [];
-        const middleware = [
-            ...declarativeMiddleware,
-            ...automaticMiddleware,
-            ...(this.options.middlewareResolver ? this.options.middlewareResolver(binding) : []),
-        ];
-        if (interruptOn && Object.keys(interruptOn).length > 0) {
-            middleware.push(humanInTheLoopMiddleware({ interruptOn }));
-        }
-        return middleware;
+        return resolveMiddlewareHelper({
+            binding,
+            interruptOn,
+            runtimeAdapterOptions: this.options,
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            resolveLangChainAutomaticMiddleware: (currentBinding) => this.resolveLangChainAutomaticMiddleware(currentBinding),
+        });
     }
     async resolveSubagents(subagents, binding) {
-        return Promise.all(subagents.map(async (subagent) => ({
-            ...subagent,
-            ...(subagent.passthrough ?? {}),
-            model: subagent.model ? (await this.resolveModel(subagent.model)) : undefined,
-            tools: subagent.tools ? this.resolveTools(subagent.tools) : undefined,
-            skills: await materializeDeepAgentSkillSourcePaths({
-                workspaceRoot: binding?.harnessRuntime.workspaceRoot,
-                runRoot: binding?.harnessRuntime.runRoot,
-                ownerId: `${binding?.agent.id ?? "agent"}-${subagent.name}`,
-                skillPaths: subagent.skills,
-            }),
-            interruptOn: compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
-            responseFormat: subagent.responseFormat,
-            contextSchema: subagent.contextSchema,
-            middleware: (await resolveDeclaredMiddleware(subagent.middleware, this.createDeclaredMiddlewareResolverOptions(binding))),
-        })));
+        return resolveSubagentsHelper({
+            subagents,
+            binding,
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+        });
     }
     async createLangChainRunnable(binding, options = {}) {
         const params = getBindingLangChainParams(binding);
@@ -517,50 +265,22 @@ export class AgentRuntimeAdapter {
             });
         };
         const callRuntimeWithToolParseRecovery = async (activeRequest) => {
-            try {
-                return await callRuntime(binding, activeRequest);
-            }
-            catch (error) {
-                if (resumePayload !== undefined || !isToolCallParseFailure(error)) {
-                    throw error;
-                }
-                return callRuntime(this.applyStrictToolJsonInstruction(binding), activeRequest);
-            }
+            return callRuntimeWithToolParseRecoveryHelper({
+                binding,
+                request: activeRequest,
+                resumePayload,
+                callRuntime,
+            });
         };
         const primaryTools = getBindingPrimaryTools(binding);
         const resolvedTools = this.resolveTools(primaryTools, binding);
         const toolNameMapping = buildToolNameMapping(primaryTools);
-        const executableTools = new Map();
-        for (let index = 0; index < primaryTools.length; index += 1) {
-            const compiledTool = primaryTools[index];
-            const resolvedTool = resolvedTools[index];
-            if (!compiledTool || !resolvedTool || !hasCallableToolHandler(resolvedTool)) {
-                continue;
-            }
-            const handler = async (toolInput) => {
-                const callable = typeof resolvedTool.invoke === "function"
-                    ? resolvedTool.invoke
-                    : typeof resolvedTool.call === "function"
-                        ? resolvedTool.call
-                        : resolvedTool.func;
-                if (!callable) {
-                    throw new Error(`Tool ${compiledTool.name} has no callable handler.`);
-                }
-                return Promise.resolve(callable.call(resolvedTool, toolInput, options.context ? { context: options.context } : undefined));
-            };
-            const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
-            const normalizedSchema = normalizeResolvedToolSchema(resolvedTool);
-            executableTools.set(modelFacingName, {
-                name: compiledTool.name,
-                schema: normalizedSchema,
-                invoke: handler,
-            });
-            executableTools.set(compiledTool.name, {
-                name: compiledTool.name,
-                schema: normalizedSchema,
-                invoke: handler,
-            });
-        }
+        const executableTools = buildExecutableToolMap({
+            primaryTools,
+            resolvedTools,
+            toolNameMapping,
+            context: options.context,
+        });
         const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
         const localOrUpstreamInvocation = await invokeRuntimeWithLocalTools({
             binding,

package/dist/runtime/harness/run/startup-runtime.d.ts

@@ -0,0 +1,32 @@
+import type { RunResult, ThreadSummary } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+import type { ConcurrencyConfig, RecoveryConfig } from "../../../workspace/support/workspace-ref-utils.js";
+type Startable = {
+    start(): Promise<void>;
+};
+export declare function initializeHarnessRuntime(input: {
+    persistence: RuntimePersistence;
+    healthMonitor: Startable | null;
+}): Promise<void>;
+export declare function recoverStartupRuns(input: {
+    recoveryConfig: RecoveryConfig;
+    persistence: RuntimePersistence;
+    createStartupRecoveryContext: () => unknown;
+    reclaimExpiredClaimedRuns: (nowIso?: string) => Promise<void>;
+}): Promise<void>;
+export declare function reclaimExpiredClaimedRuns(input: {
+    persistence: RuntimePersistence;
+    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>;
+    concurrencyConfig: ConcurrencyConfig;
+    getActiveRunSlots: () => number;
+}, nowIso?: string): Promise<void>;
+export declare function isStaleRunningRun(input: {
+    persistence: RuntimePersistence;
+    concurrencyConfig: ConcurrencyConfig;
+}, thread: ThreadSummary, nowMs?: number): Promise<boolean>;
+export {};

package/dist/runtime/harness/run/startup-runtime.js

@@ -0,0 +1,23 @@
+export async function initializeHarnessRuntime(input) {
+    await input.persistence.initialize();
+    await input.healthMonitor?.start();
+}
+export async function recoverStartupRuns(input) {
+    void input;
+}
+export async function reclaimExpiredClaimedRuns(input, nowIso = new Date().toISOString()) {
+    void input;
+    void nowIso;
+}
+export async function isStaleRunningRun(input, thread, nowMs = Date.now()) {
+    const control = await input.persistence.getRunControl(thread.latestRunId);
+    const heartbeatAt = control?.heartbeatAt;
+    if (!heartbeatAt) {
+        return true;
+    }
+    const heartbeatAtMs = Date.parse(heartbeatAt);
+    if (!Number.isFinite(heartbeatAtMs)) {
+        return true;
+    }
+    return nowMs - heartbeatAtMs >= input.concurrencyConfig.heartbeatTimeoutMs;
+}

package/dist/runtime/harness/run/thread-records.d.ts

@@ -0,0 +1,21 @@
+import type { ApprovalRecord, ThreadRecord, ThreadSummary } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+export declare function getThreadRecord(input: {
+    persistence: RuntimePersistence;
+    getSession: (threadId: string) => Promise<ThreadSummary | null>;
+}, threadId: string): Promise<ThreadRecord | null>;
+export declare function listPublicApprovals(input: {
+    persistence: RuntimePersistence;
+}, filter?: {
+    status?: ApprovalRecord["status"];
+    threadId?: string;
+    runId?: string;
+}): Promise<ApprovalRecord[]>;
+export declare function getPublicApproval(input: {
+    persistence: RuntimePersistence;
+}, approvalId: string): Promise<ApprovalRecord | null>;
+export declare function deleteThreadRecord(input: {
+    getThread: (threadId: string) => Promise<ThreadRecord | null>;
+    deleteThread: (threadId: string) => Promise<boolean>;
+    deleteThreadCheckpoints: (threadId: string) => Promise<void>;
+}, threadId: string): Promise<boolean>;

package/dist/runtime/harness/run/thread-records.js

@@ -0,0 +1,59 @@
+import { isTerminalRunState, toPublicApprovalRecord } from "./helpers.js";
+export async function getThreadRecord(input, threadId) {
+    const [threadSummary, meta, messages, runs] = await Promise.all([
+        input.getSession(threadId),
+        input.persistence.getThreadMeta(threadId),
+        input.persistence.listThreadMessages(threadId, 200),
+        input.persistence.listThreadRuns(threadId),
+    ]);
+    if (!threadSummary || !meta) {
+        return null;
+    }
+    const latestRunId = threadSummary.latestRunId;
+    const latestApprovals = await input.persistence.getRunApprovals(threadId, latestRunId);
+    const pendingApproval = latestApprovals
+        .filter((approval) => approval.status === "pending")
+        .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
+    return {
+        threadId,
+        entryAgentId: meta.entryAgentId,
+        currentState: threadSummary.status,
+        latestRunId,
+        createdAt: meta.createdAt,
+        updatedAt: threadSummary.updatedAt,
+        messages,
+        runs,
+        pendingDecision: pendingApproval
+            ? {
+                approvalId: pendingApproval.approvalId,
+                pendingActionId: pendingApproval.pendingActionId,
+                toolName: pendingApproval.toolName,
+                allowedDecisions: pendingApproval.allowedDecisions,
+                requestedAt: pendingApproval.requestedAt,
+            }
+            : undefined,
+    };
+}
+export async function listPublicApprovals(input, filter) {
+    const approvals = await input.persistence.listApprovals(filter);
+    return approvals.map((approval) => toPublicApprovalRecord(approval));
+}
+export async function getPublicApproval(input, approvalId) {
+    const approval = await input.persistence.getApproval(approvalId);
+    return approval ? toPublicApprovalRecord(approval) : null;
+}
+export async function deleteThreadRecord(input, threadId) {
+    const thread = await input.getThread(threadId);
+    if (!thread) {
+        return false;
+    }
+    const activeRun = thread.runs.find((run) => !isTerminalRunState(run.state));
+    if (activeRun) {
+        throw new Error(`Cannot delete thread ${threadId} while run ${activeRun.runId} is ${activeRun.state}`);
+    }
+    const deleted = await input.deleteThread(threadId);
+    if (deleted) {
+        await input.deleteThreadCheckpoints(threadId);
+    }
+    return deleted;
+}