@botbotgo/agent-harness 0.0.350 → 0.0.352

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.350";
+export declare const AGENT_HARNESS_VERSION = "0.0.352";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.350";
+export const AGENT_HARNESS_VERSION = "0.0.352";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/resources/prompts/runtime/execution-with-tool-evidence-retry.md

@@ -1 +1,5 @@
-Your previous response was rejected because it claimed execution without any tool calls. Your next response must contain real tool calls only. If this is a multi-step task and the runtime todo board does not exist yet, call write_todos first. If the todo board already exists or prior tool evidence is already available, do not restart planning or ask the user for more details; continue with the next concrete tool call instead. Do not describe completed work until the tool calls have actually run.
+Your previous response was rejected because it did not produce concrete execution evidence from the tools configured for this agent. Your next response must contain real execution tool calls only.
+
+Do not call planning-only tools such as write_todos or read_todos in this retry. Do not restart the plan, ask for more details, or describe completed work. Select one configured non-planning tool that can advance the original request, call it with concrete arguments, and then continue from that tool result.
+
+If this agent has no configured non-planning tool that can advance the original request, return a blocker instead of pretending the work is complete.

package/dist/runtime/adapter/flow/invocation-flow.js

@@ -5,6 +5,8 @@ import { invokeRuntimeWithLocalTools } from "./invoke-runtime.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../upstream-configurable-keys.js";
 import { extractVisibleOutput, tryParseJson } from "../../parsing/output-parsing.js";
+import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
+import { isEmptyFinalAiMessageError } from "../resilience.js";
 function readBindingExecutionParams(binding) {
     const params = binding.execution?.params ?? binding.deepAgentParams ?? binding.langchainAgentParams;
     return {
@@ -48,6 +50,34 @@ function hasNativeTaskDelegationIntent(value) {
     return hasNativeTaskDelegationIntent(typed.tool_calls) || hasNativeTaskDelegationIntent(typed.messages);
 }
 function readStructuredToolCall(value) {
+    const salvaged = salvageJsonToolCalls(value)[0];
+    if (salvaged) {
+        return salvaged;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const nested = readStructuredToolCall(item);
+            if (nested) {
+                return nested;
+            }
+        }
+        return null;
+    }
+    if (typeof value === "object" && value !== null) {
+        const typed = value;
+        const fromOutput = typed.output !== undefined ? readStructuredToolCall(typed.output) : null;
+        if (fromOutput) {
+            return fromOutput;
+        }
+        const fromContent = typed.content !== undefined ? readStructuredToolCall(typed.content) : null;
+        if (fromContent) {
+            return fromContent;
+        }
+        const fromMessages = typed.messages !== undefined ? readStructuredToolCall(typed.messages) : null;
+        if (fromMessages) {
+            return fromMessages;
+        }
+    }
     const text = typeof value === "string" ? value.trim() : "";
     const parsed = text ? (tryParseJson(text) ?? extractFirstJsonObject(text)) : value;
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
@@ -116,7 +146,7 @@ async function replayStructuredTaskToolCall(input) {
         return input.invocation;
     }
     const visibleOutput = extractVisibleOutput(input.invocation.result);
-    const toolCall = readStructuredToolCall(visibleOutput);
+    const toolCall = readStructuredToolCall(visibleOutput) ?? readStructuredToolCall(input.invocation.result);
     if (toolCall?.name !== "task") {
         return input.invocation;
     }
@@ -179,6 +209,20 @@ function buildDelegationOnlyRecoveryInstruction(binding, input) {
         JSON.stringify(input),
     ].join("\n");
 }
+function buildEmptyAssistantRecoveryInstruction() {
+    return [
+        "/no_think",
+        "Runtime correction: your previous assistant response was empty.",
+        "Continue the original request now.",
+        "If an available tool is needed, call exactly one valid tool with complete arguments.",
+        "If no tool is needed, return a non-empty final answer.",
+        "Do not return empty content.",
+    ].join("\n");
+}
+function isEmptyAssistantOutputError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return isEmptyFinalAiMessageError(error) || message === "empty_final_output";
+}
 function appendUserRecoveryInstruction(input, instruction) {
     const content = [
         "Runtime correction:",
@@ -246,12 +290,39 @@ export async function executeRequestInvocation(options) {
     if (!result) {
         throw new Error("Agent invocation returned no result");
     }
-    return finalizeRequestResult({
-        bindingAgentId: options.binding.agent.id,
-        sessionId: options.sessionId,
-        requestId: options.requestId,
-        result,
-        executedToolResults,
-    });
+    try {
+        return finalizeRequestResult({
+            bindingAgentId: options.binding.agent.id,
+            sessionId: options.sessionId,
+            requestId: options.requestId,
+            binding: options.binding,
+            result,
+            executedToolResults,
+        });
+    }
+    catch (error) {
+        if (options.resumePayload !== undefined || !isEmptyAssistantOutputError(error)) {
+            throw error;
+        }
+        const shouldUseDelegationRecovery = isDelegationOnlyBinding(options.binding)
+            && !hasTaskDelegationEvidence(executedToolResults)
+            && !hasNativeTaskDelegationIntent(result);
+        const recoveredRequest = appendUserRecoveryInstruction(request, shouldUseDelegationRecovery
+            ? buildDelegationOnlyRecoveryInstruction(options.binding, options.input)
+            : buildEmptyAssistantRecoveryInstruction());
+        const recoveredInvocation = await replayStructuredTaskToolCall({
+            invocation: await invokeOnce(recoveredRequest),
+            builtinExecutableTools: builtinExecutableTools,
+            toolRuntimeContext: invokeOptions.toolRuntimeContext,
+        });
+        return finalizeRequestResult({
+            bindingAgentId: options.binding.agent.id,
+            sessionId: options.sessionId,
+            requestId: options.requestId,
+            binding: options.binding,
+            result: recoveredInvocation.result,
+            executedToolResults: recoveredInvocation.executedToolResults,
+        });
+    }
 }
 export const executeRuntimeInvocation = executeRequestInvocation;

package/dist/runtime/adapter/invocation-result.d.ts

@@ -16,6 +16,13 @@ export declare function finalizeRequestResult(params: {
     bindingAgentId: string;
     sessionId: string;
     requestId: string;
+    binding?: {
+        harnessRuntime?: {
+            executionContract?: {
+                requiresPlan?: boolean;
+            };
+        };
+    };
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];
 }): RequestResult;

package/dist/runtime/adapter/invocation-result.js

@@ -1,5 +1,5 @@
 import { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, sanitizeVisibleText, tryParseJson, } from "../parsing/output-parsing.js";
-import { salvageFunctionLikeToolCall } from "../parsing/output-tool-args.js";
+import { salvageFunctionLikeToolCall, salvageJsonToolCalls } from "../parsing/output-tool-args.js";
 import { buildStateSnapshot } from "./model/message-assembly.js";
 import { asRecord } from "./tool/resolved-tool.js";
 import { renderToolFailure } from "../support/harness-support.js";
@@ -12,9 +12,30 @@ function looksLikeLeakedToolCallText(value) {
     if (salvageFunctionLikeToolCall(normalized)) {
         return true;
     }
+    if (salvageJsonToolCalls(normalized).length > 0) {
+        return true;
+    }
     const prefixedToolCallMatch = /^(?:\s*(?:Ready|Understood|Okay|Ok|Got it|Sure|All set|What is your request|Please provide a task for me to orchestrate)[.:?!]?\s*)+([A-Za-z_][A-Za-z0-9_]*\([\s\S]*\))\s*$/u.exec(normalized);
     return !!(prefixedToolCallMatch && salvageFunctionLikeToolCall(prefixedToolCallMatch[1]));
 }
+function hasIncompleteStateSnapshotPlan(stateSnapshot) {
+    if (typeof stateSnapshot !== "object" || stateSnapshot === null) {
+        return false;
+    }
+    const todos = stateSnapshot.todos;
+    if (!Array.isArray(todos)) {
+        return false;
+    }
+    return todos.some((todo) => {
+        if (typeof todo !== "object" || todo === null) {
+            return false;
+        }
+        const status = typeof todo.status === "string"
+            ? todo.status.trim().toLowerCase()
+            : "";
+        return status === "pending" || status === "in_progress";
+    });
+}
 function isPlaceholderTaskCompletion(value) {
     const normalized = sanitizeVisibleText(value).trim();
     return normalized === "Task completed";
@@ -113,6 +134,62 @@ function extractLatestSuccessfulNonTodoToolResultText(executedToolResults) {
         ?? candidates.at(-1)
         ?? "";
 }
+function readSerializedMessageType(value) {
+    if (typeof value !== "object" || value === null) {
+        return "";
+    }
+    const id = value.id;
+    if (!Array.isArray(id)) {
+        return "";
+    }
+    return id.map((item) => typeof item === "string" ? item : "").filter(Boolean).join(".");
+}
+function readToolMessageRecord(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const typed = value;
+    const messageType = readSerializedMessageType(value);
+    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null ? typed.kwargs : undefined;
+    const isToolMessage = typed.role === "tool"
+        || typed.type === "tool"
+        || messageType.endsWith("ToolMessage")
+        || kwargs?.name !== undefined && kwargs?.content !== undefined;
+    if (!isToolMessage) {
+        return null;
+    }
+    const toolNameCandidate = kwargs?.name ?? typed.name;
+    const toolName = typeof toolNameCandidate === "string" ? toolNameCandidate.trim() : "";
+    if (!toolName) {
+        return null;
+    }
+    const output = kwargs?.content ?? typed.content ?? "";
+    const status = kwargs?.status ?? typed.status;
+    const outputText = typeof output === "string" ? output : extractVisibleOutput(output);
+    return {
+        toolName,
+        output,
+        ...(status === "error" || looksLikeToolBlocker(outputText) ? { isError: true } : {}),
+    };
+}
+function extractUpstreamToolResults(value, seen = new Set()) {
+    if (typeof value !== "object" || value === null || seen.has(value)) {
+        return [];
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => extractUpstreamToolResults(item, seen));
+    }
+    const direct = readToolMessageRecord(value);
+    if (direct) {
+        return [direct];
+    }
+    const typed = value;
+    return [
+        ...extractUpstreamToolResults(typed.messages, seen),
+        ...extractUpstreamToolResults(typed.output, seen),
+    ];
+}
 function hasDelegationBlocker(executedToolResults) {
     return executedToolResults.some((toolResult) => {
         if (toolResult.toolName !== "task") {
@@ -236,7 +313,11 @@ export function extractToolResultFindingsText(executedToolResults) {
     return extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
 }
 export function finalizeRequestResult(params) {
-    const { bindingAgentId, sessionId, requestId, result, executedToolResults } = params;
+    const { bindingAgentId, sessionId, requestId, binding, result, executedToolResults } = params;
+    const allExecutedToolResults = [
+        ...executedToolResults,
+        ...extractUpstreamToolResults(result),
+    ];
     const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
     const extractedOutput = extractVisibleOutput(result);
     const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
@@ -257,7 +338,7 @@ export function finalizeRequestResult(params) {
         && contentBlocks.length === 0
         && structuredResponse === undefined
         && !files
-        && executedToolResults.length === 0
+        && allExecutedToolResults.length === 0
         && hasEmptyFinalMessage(result)
         && !hasFinalMessageToolCalls(result)) {
         throw new Error("empty_final_output");
@@ -266,20 +347,27 @@ export function finalizeRequestResult(params) {
     const output = resolveDeterministicFinalOutput({
         visibleOutput,
         toolFallback,
-        executedToolResults,
+        executedToolResults: allExecutedToolResults,
     })
         || (containsLikelySkillDocument(result) ? "" : serializedResult);
     const finalMessageText = sanitizeVisibleText(output);
     const terminalStatus = structuredTerminalStatus ?? readTerminalExecutionStatus(finalMessageText);
     const stateSnapshot = buildStateSnapshot(result);
-    const memoryCandidates = executedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
+    const hasIncompleteRequiredPlan = binding?.harnessRuntime?.executionContract?.requiresPlan === true
+        && hasIncompleteStateSnapshotPlan(stateSnapshot);
+    const hasTerminalToolBlocker = looksLikeToolBlocker(finalMessageText);
+    const memoryCandidates = allExecutedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
         sessionId,
         requestId,
         agentId: bindingAgentId,
         state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0
             ? "waiting_for_approval"
-            : mapTerminalStatusToRequestState(terminalStatus),
+            : hasIncompleteRequiredPlan
+                ? "failed"
+                : hasTerminalToolBlocker
+                    ? "failed"
+                    : mapTerminalStatusToRequestState(terminalStatus),
         interruptContent,
         output: finalMessageText,
         finalMessageText,
@@ -287,7 +375,7 @@ export function finalizeRequestResult(params) {
         ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
         ...(structuredResponse !== undefined ? { structuredResponse } : {}),
         metadata: {
-            ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
+            ...(allExecutedToolResults.length > 0 ? { executedToolResults: allExecutedToolResults } : {}),
             ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             ...(structuredResponse !== undefined ? { structuredResponse } : {}),
             ...(terminalStatus ? { terminalStatus } : {}),

package/dist/runtime/adapter/local-tool-invocation.js

@@ -4,7 +4,8 @@ import { canReplayToolCallsLocally } from "./tool/tool-replay.js";
 import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./tool/tool-arguments.js";
 import { extractMemoryCandidatesFromToolOutput } from "../harness/system/runtime-memory-candidates.js";
 import { maybePersistLargeToolOutput } from "./tool/tool-output-artifacts.js";
-import { appendToolRecoveryInstruction, extractVisibleOutput, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, sanitizeVisibleText, } from "../parsing/output-parsing.js";
+import { appendToolRecoveryInstruction, extractVisibleOutput, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, sanitizeVisibleText, STRICT_TOOL_JSON_INSTRUCTION, } from "../parsing/output-parsing.js";
+import { salvageJsonToolCalls } from "../parsing/output-tool-args.js";
 import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION } from "../prompts/runtime-prompts.js";
 const TOOL_FOLLOW_UP_INSTRUCTION = "One or more tool results are already available in this conversation. Answer the user's current request directly from the existing context and tool results. Do not ask the user to repeat inputs that are already present above.";
 function readPlanStateSummary(output) {
@@ -43,6 +44,17 @@ function hasNonTodoToolEvidence(executedToolResults) {
 function hasPlanStateEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.toolName === "write_todos" || item.toolName === "read_todos" || readPlanStateSummary(item.output) !== null);
 }
+function latestToolErrorRecoveryInstruction(executedToolResults) {
+    const latest = executedToolResults.at(-1);
+    if (!latest || latest.isError !== true) {
+        return null;
+    }
+    const message = typeof latest.output === "string" ? latest.output : JSON.stringify(latest.output);
+    return resolveToolCallRecoveryInstruction(new Error(message)) ?? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION;
+}
+function terminalToolErrorRecoveryInstruction(terminalText) {
+    return resolveToolCallRecoveryInstruction(new Error(terminalText));
+}
 function requiresPlanEvidence(binding) {
     return binding.harnessRuntime.executionContract?.requiresPlan === true;
 }
@@ -83,18 +95,24 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
         if (toolCalls.length === 0) {
             const terminalText = sanitizeVisibleText(extractVisibleOutput(result) || "");
             const hasIncompletePlanState = hasIncompleteExecutedPlan(executedToolResults);
+            const shouldEnforceIncompletePlan = requiresPlanEvidence(binding) && hasIncompletePlanState;
             const hasExecutionBeyondTodoPlanning = hasNonTodoToolEvidence(executedToolResults);
-            const recoveryInstruction = terminalText
+            const toolErrorRecoveryInstruction = latestToolErrorRecoveryInstruction(executedToolResults)
+                ?? terminalToolErrorRecoveryInstruction(terminalText);
+            const leakedJsonToolCallRecoveryInstruction = terminalText && salvageJsonToolCalls(terminalText).length > 0
+                ? STRICT_TOOL_JSON_INSTRUCTION
+                : null;
+            const recoveryInstruction = toolErrorRecoveryInstruction ?? leakedJsonToolCallRecoveryInstruction ?? (terminalText
                 ? resolveExecutionWithoutToolEvidenceTextInstruction(activeRequest, terminalText, false, {
                     hasWriteTodosEvidence: executedToolResults.some((item) => item.toolName === "write_todos"),
                     hasToolResultEvidence: hasExecutionBeyondTodoPlanning,
                     hasPlanStateEvidence: hasPlanStateEvidence(executedToolResults),
-                    hasIncompletePlanState: hasExecutionBeyondTodoPlanning && hasIncompletePlanState,
+                    hasIncompletePlanState: shouldEnforceIncompletePlan,
                     requiresPlan: requiresPlanEvidence(binding),
                 })
-                : hasIncompletePlanState && hasExecutionBeyondTodoPlanning
+                : shouldEnforceIncompletePlan
                     ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
-                    : null;
+                    : null);
             if (recoveryInstruction) {
                 if (iteration + 1 === maxToolIterations) {
                     throw new Error(`Tool-calling loop exceeded the maximum of ${maxToolIterations} iterations`);

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

@@ -9,9 +9,35 @@ import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
 import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingBuiltinToolsConfig, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingDeepAgentSubagents, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
-import { DEFAULT_SUBAGENT_PROMPT } from "../prompts/runtime-prompts.js";
+import { DEFAULT_SUBAGENT_PROMPT, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 import { createContextHygieneMiddleware } from "./middleware/context-hygiene.js";
 const INVALID_TOOL_MESSAGE_BLOCK_TYPES = new Set(["tool_use", "thinking", "redacted_thinking"]);
+const DEFAULT_BUILTIN_TASK_TIMEOUT_MS = 180_000;
+function resolveBuiltinTaskTimeoutMs(model) {
+    const timeout = model?.init?.timeout;
+    return typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0
+        ? Math.floor(timeout)
+        : DEFAULT_BUILTIN_TASK_TIMEOUT_MS;
+}
+async function withBuiltinTaskTimeout(producer, timeoutMs, subagentName) {
+    let timeoutHandle;
+    try {
+        return await Promise.race([
+            producer(),
+            new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => {
+                    reject(new Error(`Delegated agent ${subagentName} timed out after ${timeoutMs}ms.`));
+                }, timeoutMs);
+                timeoutHandle.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+}
 function extractDeepAgentTaskContent(result) {
     if (typeof result !== "object" || result === null) {
         return undefined;
@@ -32,6 +58,92 @@ function extractDeepAgentTaskContent(result) {
     }
     return undefined;
 }
+function readMessageType(message) {
+    if (typeof message !== "object" || message === null) {
+        return "";
+    }
+    if (typeof message._getType === "function") {
+        const typeName = message._getType();
+        return typeof typeName === "string" ? typeName : "";
+    }
+    const typed = message;
+    if (typeof typed.type === "string") {
+        return typed.type;
+    }
+    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null
+        ? typed.kwargs
+        : undefined;
+    if (typeof kwargs?.type === "string") {
+        return kwargs.type;
+    }
+    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null
+        ? typed.lc_kwargs
+        : undefined;
+    return typeof lcKwargs?.type === "string" ? lcKwargs.type : "";
+}
+function readMessageName(message) {
+    if (typeof message !== "object" || message === null) {
+        return "";
+    }
+    const typed = message;
+    if (typeof typed.name === "string") {
+        return typed.name;
+    }
+    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null
+        ? typed.kwargs
+        : undefined;
+    if (typeof kwargs?.name === "string") {
+        return kwargs.name;
+    }
+    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null
+        ? typed.lc_kwargs
+        : undefined;
+    return typeof lcKwargs?.name === "string" ? lcKwargs.name : "";
+}
+function readMessages(result) {
+    if (typeof result !== "object" || result === null) {
+        return [];
+    }
+    const messages = result.messages;
+    return Array.isArray(messages) ? messages : [];
+}
+function readToolNames(tools) {
+    if (!Array.isArray(tools)) {
+        return new Set();
+    }
+    return new Set(tools
+        .map((tool) => {
+        if (typeof tool !== "object" || tool === null) {
+            return "";
+        }
+        const name = tool.name;
+        return typeof name === "string" ? name : "";
+    })
+        .filter((name) => name.length > 0));
+}
+function hasSubagentExecutionToolEvidence(result, resolvedTools, configuredTools) {
+    const requiredToolNames = new Set([
+        ...readToolNames(configuredTools),
+        ...readToolNames(resolvedTools),
+    ]);
+    if (requiredToolNames.size === 0) {
+        return true;
+    }
+    for (const message of readMessages(result)) {
+        const typeName = readMessageType(message);
+        if (typeName !== "tool" && typeName !== "ToolMessage") {
+            continue;
+        }
+        const name = readMessageName(message);
+        if (name === "write_todos" || name === "read_todos") {
+            continue;
+        }
+        if (requiredToolNames.has(name)) {
+            return true;
+        }
+    }
+    return false;
+}
 export function extractSubagentRequestText(state) {
     if (!isRecord(state)) {
         return "";
@@ -257,6 +369,7 @@ export async function invokeBuiltinTaskTool(input) {
     const builtinBackend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
     const resolvedSubagents = await input.resolveSubagents(compiledSubagents, input.binding);
     const selectedSubagent = resolvedSubagents.find((subagent) => subagent.name === subagentType);
+    const selectedCompiledSubagent = compiledSubagents.find((subagent) => subagent.name === subagentType);
     if (!selectedSubagent) {
         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(", ")}`);
@@ -282,9 +395,17 @@ export async function invokeBuiltinTaskTool(input) {
         configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: `${input.binding.agent.id}:builtin-task` },
         ...(input.options?.context ? { context: input.options.context } : {}),
     };
-    const result = await runnable.invoke({
-        messages: [new HumanMessage({ content: description })],
-    }, invokeConfig);
+    const taskTimeoutMs = resolveBuiltinTaskTimeoutMs(selectedCompiledSubagent?.model ?? primaryModel);
+    const invokeSubagent = (content) => withBuiltinTaskTimeout(() => runnable.invoke({
+        messages: [new HumanMessage({ content })],
+    }, invokeConfig), taskTimeoutMs, selectedSubagent.name);
+    let result = await invokeSubagent(description);
+    if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
+        result = await invokeSubagent([description, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"));
+        if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
+            throw new Error(`Delegated agent ${selectedSubagent.name} completed without tool execution evidence.`);
+        }
+    }
     const structuredResponse = typeof result === "object" && result !== null && "structuredResponse" in result
         ? result.structuredResponse
         : undefined;

package/dist/runtime/adapter/resilience.d.ts

@@ -8,5 +8,6 @@ export type ProviderRetryPolicy = {
     backoffMs: number;
     retryableMessages: string[];
 };
+export declare function isEmptyFinalAiMessageError(error: unknown): boolean;
 export declare function resolveProviderRetryPolicy(binding: CompiledAgentBinding): ProviderRetryPolicy;
 export declare function isRetryableProviderError(binding: CompiledAgentBinding, error: unknown): boolean;

package/dist/runtime/adapter/resilience.js

@@ -31,13 +31,14 @@ export function resolveStreamIdleTimeout(binding) {
     return 60_000;
 }
 const BUILTIN_RETRYABLE_PROVIDER_MESSAGES = [
+    "eof",
     "unexpected eof",
     "other side closed",
     "socket hang up",
     "connection reset",
     "econnreset",
 ];
-function isEmptyFinalAiMessageError(error) {
+export function isEmptyFinalAiMessageError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.toLowerCase().startsWith("empty_final_ai_message:");
 }

package/dist/runtime/adapter/terminal-status.js

@@ -11,10 +11,10 @@ function normalizeTerminalStatus(value) {
 function readStatusLine(value) {
     for (const line of value.split("\n")) {
         const [key, ...rest] = line.split(":");
-        if (key?.trim().toLowerCase() !== "status") {
+        if (key?.trim().replaceAll("*", "").toLowerCase() !== "status") {
             continue;
         }
-        const statusValue = rest.join(":").trim().split(/\s+/)[0];
+        const statusValue = rest.join(":").trim().replaceAll("*", "").split(/\s+/)[0];
         const status = normalizeTerminalStatus(statusValue);
         if (status) {
             return status;

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

@@ -10,7 +10,7 @@ import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { applyToolRecoveryInstruction as applyToolRecoveryInstructionHelper, 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 { extractSubagentRequestText, invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, wrapRequestResultAsSubagentResponse, } from "./adapter/middleware-assembly.js";
-import { resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
+import { isEmptyFinalAiMessageError, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { renderDirectWorkspaceListing, shouldDirectlyListWorkspaceFiles } from "./adapter/direct-builtin-utility.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
@@ -585,7 +585,7 @@ export class AgentRuntimeAdapter {
             sessionId,
             requestId,
         });
-        return this.invokeWithProviderRetry(binding, async () => executeRequestInvocation({
+        const invokeRequest = () => executeRequestInvocation({
             binding,
             input,
             sessionId,
@@ -600,7 +600,17 @@ export class AgentRuntimeAdapter {
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
             resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, { ...currentOptions, sessionId, requestId }),
             callRuntimeWithToolParseRecovery,
-        }));
+        });
+        try {
+            return await invokeRequest();
+        }
+        catch (error) {
+            if (!isEmptyFinalAiMessageError(error)) {
+                throw error;
+            }
+            this.invalidateBindingRuntimeCaches(binding);
+            return invokeRequest();
+        }
     }
     async *stream(binding, input, sessionId, history = [], options = {}) {
         const directListing = await this.tryHandleDirectWorkspaceListing(binding, input, {

package/dist/runtime/harness/events/event-sink.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from "node:events";
 import { getEventSubscribers } from "../../../tooling/extensions.js";
+const EVENT_PROJECTION_DRAIN_TIMEOUT_MS = 1_000;
 function dispatchListener(listener, event) {
     void Promise.resolve(listener(event));
 }
@@ -34,8 +35,24 @@ export class RuntimeEventSinkImpl {
         return () => this.projections.delete(projection);
     }
     async drain() {
-        while (this.inflightProjectionTasks.size > 0) {
-            await Promise.allSettled(Array.from(this.inflightProjectionTasks));
+        let timeoutHandle;
+        try {
+            await Promise.race([
+                (async () => {
+                    while (this.inflightProjectionTasks.size > 0) {
+                        await Promise.allSettled(Array.from(this.inflightProjectionTasks));
+                    }
+                })(),
+                new Promise((resolve) => {
+                    timeoutHandle = setTimeout(resolve, EVENT_PROJECTION_DRAIN_TIMEOUT_MS);
+                    timeoutHandle.unref?.();
+                }),
+            ]);
+        }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
         }
     }
 }

package/dist/runtime/harness.d.ts

@@ -133,6 +133,7 @@ export declare class AgentHarnessRuntime {
     private trackBackgroundTask;
     private scheduleBackgroundStartupTask;
     private drainBackgroundTasksForClose;
+    private closeStageWithTimeout;
     private resolveToolMcpServerTools;
     private loadPriorHistory;
     private loadRequestInput;

package/dist/runtime/harness.js

@@ -47,6 +47,7 @@ import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessi
 import { createKnowledgeModule } from "../knowledge/index.js";
 import { createProceduralMemoryManager, ProceduralMemoryFormationSync, readProceduralMemoryRuntimeConfig, } from "../knowledge/procedural/index.js";
 const BACKGROUND_TASK_CLOSE_DRAIN_TIMEOUT_MS = 1_000;
+const CLOSE_STAGE_TIMEOUT_MS = 1_000;
 const ACTIVE_REQUEST_STATES = [
     "queued",
     "claimed",
@@ -963,6 +964,22 @@ export class AgentHarnessRuntime {
             clearTimeout(timeoutHandle);
         }
     }
+    async closeStageWithTimeout(_label, stage) {
+        if (!stage) {
+            return;
+        }
+        let timeoutHandle;
+        await Promise.race([
+            stage().then(() => undefined).catch(() => undefined),
+            new Promise((resolve) => {
+                timeoutHandle = setTimeout(resolve, CLOSE_STAGE_TIMEOUT_MS);
+                timeoutHandle.unref?.();
+            }),
+        ]);
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
     resolveToolMcpServerTools(agentId) {
         return resolveWorkspaceAgentTools({
             workspace: this.workspace,
@@ -1386,20 +1403,20 @@ export class AgentHarnessRuntime {
             return;
         }
         this.closed = true;
-        await this.healthMonitor?.stop();
-        await this.eventBus.drain();
+        await this.closeStageWithTimeout("healthMonitor.stop", () => this.healthMonitor?.stop() ?? Promise.resolve());
+        await this.closeStageWithTimeout("eventBus.drain", () => this.eventBus.drain());
         this.unregisterSessionMemorySync();
         this.unregisterRuntimeMemorySync();
         this.unregisterMem0IngestionSync();
         this.unregisterRuntimeMemoryFormationSync();
         this.unregisterProceduralMemoryFormationSync();
         await this.drainBackgroundTasksForClose();
-        await this.sessionMemorySync?.close();
-        await this.runtimeMemorySync?.close();
-        await this.mem0IngestionSync?.close();
-        await this.runtimeMemoryFormationSync?.close();
-        await this.proceduralMemoryFormationSync?.close();
-        await closeMcpClientsForWorkspace(this.workspace);
+        await this.closeStageWithTimeout("sessionMemorySync.close", () => this.sessionMemorySync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("runtimeMemorySync.close", () => this.runtimeMemorySync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("mem0IngestionSync.close", () => this.mem0IngestionSync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("runtimeMemoryFormationSync.close", () => this.runtimeMemoryFormationSync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("proceduralMemoryFormationSync.close", () => this.proceduralMemoryFormationSync?.close() ?? Promise.resolve());
+        await this.closeStageWithTimeout("closeMcpClientsForWorkspace", () => closeMcpClientsForWorkspace(this.workspace));
         this.initialized = false;
     }
     async stop() {

package/dist/runtime/parsing/output-content.js

@@ -1,5 +1,5 @@
 import { AIMessage } from "langchain";
-import { salvageFunctionLikeToolCall, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
+import { salvageFunctionLikeToolCall, salvageJsonToolCalls, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
 function consumeLeadingFunctionLikeToolCall(value) {
     const match = /^([A-Za-z_][A-Za-z0-9_]*)\(/.exec(value);
     if (!match) {
@@ -495,8 +495,12 @@ function normalizeAgentMessage(value) {
     const functionLikeToolCall = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && typeof normalizedContent === "string"
         ? salvageFunctionLikeToolCall(normalizedContent)
         : null;
+    const jsonToolCalls = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && !functionLikeToolCall && typeof normalizedContent === "string"
+        ? salvageJsonToolCalls(normalizedContent)
+        : [];
+    const hasRecoveredContentToolCalls = Boolean(functionLikeToolCall) || jsonToolCalls.length > 0;
     return new AIMessage({
-        content: functionLikeToolCall ? "" : normalizedContent,
+        content: hasRecoveredContentToolCalls ? "" : normalizedContent,
         name: typeof typed.name === "string" ? typed.name : undefined,
         additional_kwargs: typeof typed.additional_kwargs === "object" && typed.additional_kwargs ? typed.additional_kwargs : {},
         response_metadata: typeof typed.response_metadata === "object" && typed.response_metadata ? typed.response_metadata : {},
@@ -505,6 +509,7 @@ function normalizeAgentMessage(value) {
             ...normalizedToolCalls,
             ...recoveredToolCalls,
             ...(functionLikeToolCall ? [{ name: functionLikeToolCall.name, args: functionLikeToolCall.args }] : []),
+            ...jsonToolCalls.map((toolCall) => ({ name: toolCall.name, args: toolCall.args })),
         ],
         invalid_tool_calls: normalizedInvalidToolCalls.filter((toolCall) => toolCall.type !== "tool_call"),
         usage_metadata: typeof typed.usage_metadata === "object" && typed.usage_metadata ? typed.usage_metadata : undefined,

package/dist/runtime/parsing/output-recovery.js

@@ -1,5 +1,6 @@
 import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 import { wrapNormalizedMessage, readTextContent } from "./output-content.js";
+import { salvageJsonToolCalls } from "./output-tool-args.js";
 function collectRequestMessages(request) {
     if (typeof request !== "object" || !request || Array.isArray(request)) {
         return [];
@@ -145,12 +146,15 @@ export function resolveExecutionWithoutToolEvidenceTextInstruction(request, assi
     const hasUnfinishedExecution = resultEvidence.hasIncompletePlanState === true
         || resultEvidence.hasOpenTaskDelegation === true
         || resultEvidence.hasMissingDelegatedExecutionEvidence === true;
-    if (!normalizedText || !hasUnfinishedExecution) {
-        return null;
+    if (salvageJsonToolCalls(normalizedText).length > 0) {
+        return STRICT_TOOL_JSON_INSTRUCTION;
     }
     const hasExecutionEvidence = toolCallEvidence
         || resultEvidence.hasWriteTodosEvidence === true
         || resultEvidence.hasToolResultEvidence === true;
+    if (!normalizedText || !hasUnfinishedExecution) {
+        return null;
+    }
     return hasExecutionEvidence
         ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
         : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;

package/dist/runtime/parsing/output-tool-args.d.ts

@@ -4,5 +4,9 @@ export declare function salvageFunctionLikeToolCall(value: unknown): {
     args: Record<string, unknown>;
 } | null;
 export declare function salvageToolArgs(value: unknown): Record<string, unknown> | null;
+export declare function salvageJsonToolCalls(value: unknown): Array<{
+    name: string;
+    args: Record<string, unknown>;
+}>;
 export declare function normalizeKnownToolArgs(toolName: unknown, args: Record<string, unknown>): Record<string, unknown>;
 export declare function isLikelyToolArgsObject(value: unknown): boolean;

package/dist/runtime/parsing/output-tool-args.js

@@ -112,8 +112,8 @@ export function salvageFunctionLikeToolCall(value) {
     }
     return { name, args: normalizeKnownToolArgs(name, args) };
 }
-function extractBalancedJsonObject(value) {
-    const start = value.indexOf("{");
+function extractBalancedJsonValue(value, openChar, closeChar) {
+    const start = value.indexOf(openChar);
     if (start < 0)
         return null;
     let depth = 0;
@@ -139,11 +139,11 @@ function extractBalancedJsonObject(value) {
             inString = true;
             continue;
         }
-        if (char === "{") {
+        if (char === openChar) {
             depth += 1;
             continue;
         }
-        if (char === "}") {
+        if (char === closeChar) {
             depth -= 1;
             if (depth === 0) {
                 return value.slice(start, index + 1);
@@ -152,6 +152,59 @@ function extractBalancedJsonObject(value) {
     }
     return null;
 }
+function extractBalancedJsonObject(value) {
+    return extractBalancedJsonValue(value, "{", "}");
+}
+function extractBalancedJsonArray(value) {
+    return extractBalancedJsonValue(value, "[", "]");
+}
+function closeJsonContainerSuffix(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+        return null;
+    }
+    const stack = [];
+    let inString = false;
+    let escaping = false;
+    for (const char of trimmed) {
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaping = true;
+                continue;
+            }
+            if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            stack.push("}");
+            continue;
+        }
+        if (char === "[") {
+            stack.push("]");
+            continue;
+        }
+        if (char === "}" || char === "]") {
+            const expected = stack.pop();
+            if (expected !== char) {
+                return null;
+            }
+        }
+    }
+    if (inString || stack.length === 0) {
+        return null;
+    }
+    return `${trimmed}${stack.reverse().join("")}`;
+}
 export function salvageToolArgs(value) {
     if (typeof value === "object" && value && !Array.isArray(value)) {
         return value;
@@ -174,6 +227,63 @@ export function salvageToolArgs(value) {
     const parsed = tryParseJson(embedded);
     return typeof parsed === "object" && parsed && !Array.isArray(parsed) ? parsed : null;
 }
+function normalizeJsonToolCallPayload(payload) {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        return null;
+    }
+    const typed = payload;
+    const functionPayload = typeof typed.function === "object" && typed.function !== null ? typed.function : undefined;
+    const nameCandidate = typed.name ?? typed.tool ?? functionPayload?.name;
+    const name = typeof nameCandidate === "string" ? nameCandidate.trim() : "";
+    if (!name) {
+        return null;
+    }
+    const argsCandidate = typed.arguments ?? typed.args ?? typed.parameters ?? typed.input ?? functionPayload?.arguments ?? {};
+    const args = Array.isArray(argsCandidate)
+        ? { args: argsCandidate }
+        : salvageToolArgs(argsCandidate) ?? {};
+    return { name, args: normalizeKnownToolArgs(name, args) };
+}
+export function salvageJsonToolCalls(value) {
+    const payload = typeof value === "string"
+        ? (() => {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                return null;
+            }
+            const direct = tryParseJson(trimmed);
+            if (direct) {
+                return direct;
+            }
+            const closed = closeJsonContainerSuffix(trimmed);
+            if (closed) {
+                const parsed = tryParseJson(closed);
+                if (parsed) {
+                    return parsed;
+                }
+            }
+            const embeddedArray = extractBalancedJsonArray(trimmed);
+            if (embeddedArray) {
+                const parsed = tryParseJson(embeddedArray);
+                if (parsed) {
+                    return parsed;
+                }
+            }
+            const embeddedObject = extractBalancedJsonObject(trimmed);
+            if (embeddedObject) {
+                const parsed = tryParseJson(embeddedObject);
+                if (parsed) {
+                    return parsed;
+                }
+            }
+            return null;
+        })()
+        : value;
+    const candidates = Array.isArray(payload) ? payload : [payload];
+    return candidates
+        .map((item) => normalizeJsonToolCallPayload(item))
+        .filter((item) => item !== null);
+}
 function normalizeWriteTodosArgs(args) {
     if (!Array.isArray(args.todos)) {
         return args;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.350",
+  "version": "0.0.352",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",