@botbotgo/agent-harness 0.0.345 → 0.0.347

package/dist/contracts/runtime-requests.d.ts

@@ -17,6 +17,7 @@ export type RequestResult = {
     artifacts?: ArtifactRecord[];
     metadata?: Record<string, unknown>;
 };
+export type TerminalExecutionStatus = "completed" | "blocked" | "failed" | "refused";
 export type UpstreamRuntimeEvent = unknown;
 export type UpstreamRuntimeEventItem = {
     sessionId: string;

package/dist/contracts/workspace.d.ts

@@ -203,6 +203,9 @@ export type CompiledBuiltinToolsConfig = {
     todos?: boolean;
     modelExposed?: boolean | string[];
 };
+export type CompiledExecutionContract = {
+    requiresPlan?: boolean;
+};
 export type LangChainAgentParams = {
     model: CompiledModel;
     tools: CompiledTool[];
@@ -287,6 +290,7 @@ export type CompiledAgentBinding = {
         resilience?: Record<string, unknown>;
         governance?: Record<string, unknown>;
         observability?: Record<string, unknown>;
+        executionContract?: CompiledExecutionContract;
         deepagent?: {
             description?: string;
             passthrough?: Record<string, unknown>;

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.345";
+export declare const AGENT_HARNESS_VERSION = "0.0.347";
 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.345";
+export const AGENT_HARNESS_VERSION = "0.0.347";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/resources/prompts/runtime/delegated-task-failure-recovery.md

@@ -0,0 +1,8 @@
+The delegated task failed. You are the routing/delegation parent agent, so you must not switch into local execution or start a new local plan.
+
+Your next response has only two valid forms:
+
+1. Call the `task` tool again, preserving the user's original request and delegating to the same specialist or another explicit specialist whose configured responsibility clearly matches the original request.
+2. Return a final blocker report to the user explaining that delegated execution failed.
+
+Do not call local execution tools, repository tools, web tools, shell tools, or `write_todos` from the parent agent after this delegated failure. Do not invent a new topic or downgrade the original request. If you continue execution, it must be through `task`.

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

@@ -1,4 +1,5 @@
 import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
+import { DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION } from "../../prompts/runtime-prompts.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
@@ -55,6 +56,18 @@ function hasSuccessfulNonTodoToolEvidence(executedToolResults) {
 function hasSuccessfulTaskToolEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.isError !== true && item.toolName === "task");
 }
+function requiresPlanEvidence(binding) {
+    return binding.harnessRuntime?.executionContract?.requiresPlan === true;
+}
+function hasParentLocalToolExecutionAfterDelegationFailure(originalEvidence, executedToolResults) {
+    return originalEvidence.hasFailedTaskDelegation
+        && executedToolResults.some((item) => item.toolName !== "task");
+}
+function isDelegationFailureFinalReport(originalEvidence, executedToolResults, visibleOutput) {
+    return originalEvidence.hasFailedTaskDelegation
+        && executedToolResults.length === 0
+        && visibleOutput.trim().length > 0;
+}
 function buildExecutionRecoveryEvidence(params) {
     const { projectionState, executedToolResults = [] } = params;
     return {
@@ -65,7 +78,8 @@ function buildExecutionRecoveryEvidence(params) {
         hasIncompletePlanState: projectionState.hasIncompletePlanState || hasIncompletePlanStateInExecutedToolResults(executedToolResults),
         hasPlanStateEvidence: projectionState.sawPlanState || hasIncompletePlanStateInExecutedToolResults(executedToolResults),
         hasOpenTaskDelegation: projectionState.openTaskDelegations > 0,
-        hasFailedTaskDelegation: projectionState.hasFailedTaskDelegation,
+        hasFailedTaskDelegation: projectionState.hasFailedTaskDelegation
+            || executedToolResults.some((item) => item.toolName === "task" && item.isError === true),
         hasDelegatedAgentWithConfiguredTools: projectionState.sawDelegatedAgentWithConfiguredTools,
         hasDelegatedExecutionToolEvidence: projectionState.emittedDelegatedExecutionToolResult,
         hasOnlyPlaceholderTaskCompletion: projectionState.emittedSuccessfulTaskResult
@@ -98,6 +112,9 @@ function resolveStreamedRuntimeFailureRecoveryInstruction(output, evidence) {
     return hasExecutionEvidence ? null : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;
 }
 function resolveDelegatedExecutionRecoveryInstruction(evidence) {
+    if (evidence.hasFailedTaskDelegation) {
+        return DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION;
+    }
     if (hasMissingDelegatedFindings(evidence)
         || (evidence.hasOpenTaskDelegation
             && evidence.hasDelegatedAgentWithConfiguredTools
@@ -400,6 +417,7 @@ export async function* streamRuntimeExecution(options) {
                             ? resolveMissingPlanRecoveryInstruction({
                                 request,
                                 assistantText: terminalVisibleOutput,
+                                requiresPlan: requiresPlanEvidence(options.binding),
                                 hasPlanStateEvidence: terminalExecutionEvidence.hasPlanStateEvidence,
                                 hasWriteTodosEvidence: terminalExecutionEvidence.hasPlanStateEvidence,
                                 hasToolResultEvidence: terminalExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
@@ -443,8 +461,9 @@ export async function* streamRuntimeExecution(options) {
                 throw error;
             }
             const streamedExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
-            const delegatedExecutionRecoveryInstruction = !emittedUnsafeStreamSideEffects
-                ? resolveDelegatedExecutionRecoveryInstruction(streamedExecutionEvidence)
+            const streamedDelegatedRecoveryInstruction = resolveDelegatedExecutionRecoveryInstruction(streamedExecutionEvidence);
+            const delegatedExecutionRecoveryInstruction = !emittedUnsafeStreamSideEffects || streamedDelegatedRecoveryInstruction
+                ? streamedDelegatedRecoveryInstruction
                 : null;
             if (hasUnresolvedExecution(streamedExecutionEvidence) && !delegatedExecutionRecoveryInstruction) {
                 throw createUnresolvedExecutionError(streamedExecutionEvidence);
@@ -453,6 +472,7 @@ export async function* streamRuntimeExecution(options) {
                 ? resolveExecutionWithoutToolEvidenceTextInstruction(request, projectionState.emittedOutput, false, {
                     ...streamedExecutionEvidence,
                     hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(streamedExecutionEvidence),
+                    requiresPlan: requiresPlanEvidence(options.binding),
                 })
                 : null;
             const streamedRuntimeFailureRecoveryInstruction = projectionState.emittedOutput
@@ -462,6 +482,7 @@ export async function* streamRuntimeExecution(options) {
                 ? resolveMissingPlanRecoveryInstruction({
                     request,
                     assistantText: projectionState.emittedOutput,
+                    requiresPlan: requiresPlanEvidence(options.binding),
                     hasPlanStateEvidence: streamedExecutionEvidence.hasPlanStateEvidence,
                     hasWriteTodosEvidence: streamedExecutionEvidence.hasPlanStateEvidence,
                     hasToolResultEvidence: streamedExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
@@ -484,17 +505,22 @@ export async function* streamRuntimeExecution(options) {
                     projectionState: createStreamEventProjectionState(),
                     executedToolResults,
                 });
+                if (hasParentLocalToolExecutionAfterDelegationFailure(originalExecutionEvidence, executedToolResults)) {
+                    throw new ExecutionReconciliationError("Agent attempted parent-local tool execution after delegated task failure; it must report a blocker or re-delegate with task.");
+                }
                 const retriedVisibleOutput = retried.output ? toVisibleContent(retried.output) : "";
+                const retriedIsDelegationFailureFinalReport = isDelegationFailureFinalReport(originalExecutionEvidence, executedToolResults, retriedVisibleOutput);
                 const retriedCarriesExecutionEvidence = retriedExecutionEvidence.hasToolResultEvidence
                     || retriedExecutionEvidence.hasOpenTaskDelegation
                     || retriedExecutionEvidence.hasDelegatedExecutionToolEvidence;
-                const retriedHasUnresolvedExecution = hasUnresolvedExecution(retriedExecutionEvidence)
-                    || hasMissingDelegatedExecutionEvidence(retriedExecutionEvidence)
-                    || hasMissingDelegatedFindings(retriedExecutionEvidence)
-                    || (!retriedCarriesExecutionEvidence
-                        && (hasUnresolvedExecution(originalExecutionEvidence)
-                            || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
-                            || hasMissingDelegatedFindings(originalExecutionEvidence)));
+                const retriedHasUnresolvedExecution = !retriedIsDelegationFailureFinalReport
+                    && (hasUnresolvedExecution(retriedExecutionEvidence)
+                        || hasMissingDelegatedExecutionEvidence(retriedExecutionEvidence)
+                        || hasMissingDelegatedFindings(retriedExecutionEvidence)
+                        || (!retriedCarriesExecutionEvidence
+                            && (hasUnresolvedExecution(originalExecutionEvidence)
+                                || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
+                                || hasMissingDelegatedFindings(originalExecutionEvidence))));
                 const effectiveRecoveryEvidence = retriedCarriesExecutionEvidence
                     ? retriedExecutionEvidence
                     : {
@@ -666,12 +692,14 @@ export async function* streamRuntimeExecution(options) {
             ? resolveExecutionWithoutToolEvidenceTextInstruction(request, result.output, false, {
                 ...invokeExecutionEvidence,
                 hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(invokeExecutionEvidence),
+                requiresPlan: requiresPlanEvidence(options.binding),
             })
             : resolveDelegatedExecutionRecoveryInstruction(invokeExecutionEvidence);
         const invokeFallbackMissingPlanRecoveryInstruction = !hasUnresolvedExecution(invokeExecutionEvidence) && !invokeFallbackRecoveryInstruction
             ? resolveMissingPlanRecoveryInstruction({
                 request,
                 assistantText: typeof result.output === "string" ? result.output : "",
+                requiresPlan: requiresPlanEvidence(options.binding),
                 hasPlanStateEvidence: invokeExecutionEvidence.hasPlanStateEvidence,
                 hasWriteTodosEvidence: invokeExecutionEvidence.hasPlanStateEvidence,
                 hasToolResultEvidence: invokeExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
@@ -688,17 +716,22 @@ export async function* streamRuntimeExecution(options) {
                 projectionState: createStreamEventProjectionState(),
                 executedToolResults: recoveredToolResults,
             });
+            if (hasParentLocalToolExecutionAfterDelegationFailure(originalExecutionEvidence, recoveredToolResults)) {
+                throw new ExecutionReconciliationError("Agent attempted parent-local tool execution after delegated task failure; it must report a blocker or re-delegate with task.");
+            }
             const recoveredVisibleOutput = recovered.output ? toVisibleContent(recovered.output) : "";
+            const recoveredIsDelegationFailureFinalReport = isDelegationFailureFinalReport(originalExecutionEvidence, recoveredToolResults, recoveredVisibleOutput);
             const recoveredCarriesExecutionEvidence = recoveredExecutionEvidence.hasToolResultEvidence
                 || recoveredExecutionEvidence.hasOpenTaskDelegation
                 || recoveredExecutionEvidence.hasDelegatedExecutionToolEvidence;
-            const recoveredHasUnresolvedExecution = hasUnresolvedExecution(recoveredExecutionEvidence)
-                || hasMissingDelegatedExecutionEvidence(recoveredExecutionEvidence)
-                || hasMissingDelegatedFindings(recoveredExecutionEvidence)
-                || (!recoveredCarriesExecutionEvidence
-                    && (hasUnresolvedExecution(originalExecutionEvidence)
-                        || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
-                        || hasMissingDelegatedFindings(originalExecutionEvidence)));
+            const recoveredHasUnresolvedExecution = !recoveredIsDelegationFailureFinalReport
+                && (hasUnresolvedExecution(recoveredExecutionEvidence)
+                    || hasMissingDelegatedExecutionEvidence(recoveredExecutionEvidence)
+                    || hasMissingDelegatedFindings(recoveredExecutionEvidence)
+                    || (!recoveredCarriesExecutionEvidence
+                        && (hasUnresolvedExecution(originalExecutionEvidence)
+                            || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
+                            || hasMissingDelegatedFindings(originalExecutionEvidence))));
             const effectiveRecoveredEvidence = recoveredCarriesExecutionEvidence
                 ? recoveredExecutionEvidence
                 : {

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

@@ -3,6 +3,7 @@ import { salvageFunctionLikeToolCall } 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";
+import { mapTerminalStatusToRequestState, readTerminalExecutionStatus } from "./terminal-status.js";
 function looksLikeLeakedToolCallText(value) {
     const normalized = sanitizeVisibleText(value).trim();
     if (!normalized) {
@@ -168,6 +169,29 @@ function extractDeterministicToolFailureReport(executedToolResults) {
         "- none",
     ].join("\n");
 }
+function hasEmptyFinalMessage(result) {
+    const messages = Array.isArray(result.messages) ? result.messages : [];
+    const lastMessage = messages.at(-1);
+    if (!lastMessage || typeof lastMessage !== "object") {
+        return false;
+    }
+    const direct = lastMessage;
+    return direct.content === "" || direct.kwargs?.content === "" || direct.lc_kwargs?.content === "";
+}
+function hasFinalMessageToolCalls(result) {
+    const messages = Array.isArray(result.messages) ? result.messages : [];
+    const lastMessage = messages.at(-1);
+    if (!lastMessage || typeof lastMessage !== "object") {
+        return false;
+    }
+    const direct = lastMessage;
+    return Array.isArray(direct.tool_calls) && direct.tool_calls.length > 0
+        || Array.isArray(direct.invalid_tool_calls) && direct.invalid_tool_calls.length > 0
+        || Array.isArray(direct.kwargs?.tool_calls) && direct.kwargs.tool_calls.length > 0
+        || Array.isArray(direct.kwargs?.invalid_tool_calls) && direct.kwargs.invalid_tool_calls.length > 0
+        || Array.isArray(direct.lc_kwargs?.tool_calls) && direct.lc_kwargs.tool_calls.length > 0
+        || Array.isArray(direct.lc_kwargs?.invalid_tool_calls) && direct.lc_kwargs.invalid_tool_calls.length > 0;
+}
 export function resolveDeterministicFinalOutput(params) {
     const visibleOutput = params.visibleOutput ?? "";
     const toolFallback = params.toolFallback ?? "";
@@ -178,6 +202,9 @@ export function resolveDeterministicFinalOutput(params) {
     const deterministicFailureReport = extractDeterministicToolFailureReport(executedToolResults);
     const delegatedTaskOutput = extractLatestSuccessfulTaskResultText(executedToolResults);
     const successfulToolOutput = extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
+    if (sanitizedVisibleOutput && deterministicFailureReport && hasDelegationBlocker(executedToolResults) && !successfulToolOutput) {
+        return deterministicFailureReport;
+    }
     if (sanitizedVisibleOutput && successfulToolOutput && hasDelegationBlocker(executedToolResults)) {
         return deterministicFailureReport || delegatedTaskOutput || successfulToolOutput;
     }
@@ -215,9 +242,26 @@ export function finalizeRequestResult(params) {
     const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
     const emptyAssistantMessageFailure = extractEmptyAssistantMessageFailure(result);
     const toolFallback = extractToolFallbackContext(result);
+    const outputContent = extractOutputContent(result);
+    const contentBlocks = extractContentBlocks(result);
+    const structuredResponse = result.structuredResponse;
+    const structuredTerminalStatus = readTerminalExecutionStatus(structuredResponse) ?? readTerminalExecutionStatus(result);
+    const files = asRecord(result.files);
     if (!visibleOutput && !toolFallback && emptyAssistantMessageFailure) {
         throw new Error(emptyAssistantMessageFailure);
     }
+    if (!visibleOutput
+        && !toolFallback
+        && interruptContent === undefined
+        && outputContent === undefined
+        && contentBlocks.length === 0
+        && structuredResponse === undefined
+        && !files
+        && executedToolResults.length === 0
+        && hasEmptyFinalMessage(result)
+        && !hasFinalMessageToolCalls(result)) {
+        throw new Error("empty_final_output");
+    }
     const serializedResult = JSON.stringify(result, null, 2);
     const output = resolveDeterministicFinalOutput({
         visibleOutput,
@@ -226,17 +270,16 @@ export function finalizeRequestResult(params) {
     })
         || (containsLikelySkillDocument(result) ? "" : serializedResult);
     const finalMessageText = sanitizeVisibleText(output);
-    const outputContent = extractOutputContent(result);
-    const contentBlocks = extractContentBlocks(result);
-    const structuredResponse = result.structuredResponse;
-    const files = asRecord(result.files);
+    const terminalStatus = structuredTerminalStatus ?? readTerminalExecutionStatus(finalMessageText);
     const stateSnapshot = buildStateSnapshot(result);
     const memoryCandidates = executedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
         sessionId,
         requestId,
         agentId: bindingAgentId,
-        state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
+        state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0
+            ? "waiting_for_approval"
+            : mapTerminalStatusToRequestState(terminalStatus),
         interruptContent,
         output: finalMessageText,
         finalMessageText,
@@ -247,6 +290,7 @@ export function finalizeRequestResult(params) {
             ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
             ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             ...(structuredResponse !== undefined ? { structuredResponse } : {}),
+            ...(terminalStatus ? { terminalStatus } : {}),
             ...(outputContent !== undefined ? { outputContent } : {}),
             ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
             ...(files ? { files } : {}),

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

@@ -43,6 +43,9 @@ function hasNonTodoToolEvidence(executedToolResults) {
 function hasPlanStateEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.toolName === "write_todos" || item.toolName === "read_todos" || readPlanStateSummary(item.output) !== null);
 }
+function requiresPlanEvidence(binding) {
+    return binding.harnessRuntime.executionContract?.requiresPlan === true;
+}
 function extractLatestUserInput(request) {
     const typedRequest = request;
     const messages = Array.isArray(typedRequest.messages) ? typedRequest.messages : [];
@@ -87,6 +90,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                     hasToolResultEvidence: hasExecutionBeyondTodoPlanning,
                     hasPlanStateEvidence: hasPlanStateEvidence(executedToolResults),
                     hasIncompletePlanState: hasExecutionBeyondTodoPlanning && hasIncompletePlanState,
+                    requiresPlan: requiresPlanEvidence(binding),
                 })
                 : hasIncompletePlanState && hasExecutionBeyondTodoPlanning
                     ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
@@ -102,6 +106,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
         }
         const missingPlanRecoveryInstruction = resolveMissingPlanRecoveryInstruction({
             request: activeRequest,
+            requiresPlan: requiresPlanEvidence(binding),
             hasPlanStateEvidence: hasPlanStateEvidence(executedToolResults),
             hasWriteTodosEvidence: executedToolResults.some((item) => item.toolName === "write_todos"),
             hasToolResultEvidence: executedToolResults.length > 0 || toolCalls.length > 0,

package/dist/runtime/adapter/stream-event-projection.js

@@ -350,7 +350,9 @@ export function projectRuntimeStreamEvent(params) {
             ? state.lastCompletedTaskDelegationFindings
             : "";
         const effectiveToolOutput = salvagedTaskErrorFindings || toolResult.output;
-        const effectiveToolIsError = salvagedTaskErrorFindings ? false : toolResult.isError;
+        const effectiveToolIsError = salvagedTaskErrorFindings
+            ? false
+            : toolResult.isError === true;
         const isSuccessfulTaskResult = toolResult.toolName === "task" && effectiveToolIsError !== true;
         const isDelegatedExecutionTool = (isDelegatedAgentEvent || state.openToolCapableTaskDelegations > 0)
             && toolResult.toolName !== "write_todos"

package/dist/runtime/adapter/terminal-status.d.ts

@@ -0,0 +1,4 @@
+import type { RequestState, TerminalExecutionStatus } from "../../contracts/types.js";
+export declare function readTerminalExecutionStatus(value: unknown): TerminalExecutionStatus | null;
+export declare function mapTerminalStatusToRequestState(status: TerminalExecutionStatus | null): RequestState;
+export declare function mapTerminalStatusToPlanItemStatus(status: TerminalExecutionStatus): "completed" | "failed";

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

@@ -0,0 +1,67 @@
+const TERMINAL_STATUSES = new Set(["completed", "blocked", "failed", "refused"]);
+function normalizeTerminalStatus(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    return TERMINAL_STATUSES.has(normalized)
+        ? normalized
+        : null;
+}
+function readStatusLine(value) {
+    for (const line of value.split("\n")) {
+        const [key, ...rest] = line.split(":");
+        if (key?.trim().toLowerCase() !== "status") {
+            continue;
+        }
+        const statusValue = rest.join(":").trim().split(/\s+/)[0];
+        const status = normalizeTerminalStatus(statusValue);
+        if (status) {
+            return status;
+        }
+    }
+    return null;
+}
+export function readTerminalExecutionStatus(value) {
+    const direct = normalizeTerminalStatus(value);
+    if (direct) {
+        return direct;
+    }
+    if (typeof value === "string") {
+        try {
+            return readTerminalExecutionStatus(JSON.parse(value));
+        }
+        catch {
+            return readStatusLine(value);
+        }
+    }
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        for (let index = value.length - 1; index >= 0; index -= 1) {
+            const status = readTerminalExecutionStatus(value[index]);
+            if (status) {
+                return status;
+            }
+        }
+        return null;
+    }
+    const typed = value;
+    return (readTerminalExecutionStatus(typed.status)
+        ?? readTerminalExecutionStatus(typed.structuredResponse)
+        ?? readTerminalExecutionStatus(typed.messages)
+        ?? readTerminalExecutionStatus(typed.content)
+        ?? readTerminalExecutionStatus(typed.kwargs?.content)
+        ?? readTerminalExecutionStatus(typed.lc_kwargs?.content)
+        ?? readTerminalExecutionStatus(typed.output)
+        ?? readTerminalExecutionStatus(typed.data));
+}
+export function mapTerminalStatusToRequestState(status) {
+    return status === "blocked" || status === "failed" || status === "refused"
+        ? "failed"
+        : "completed";
+}
+export function mapTerminalStatusToPlanItemStatus(status) {
+    return status === "completed" ? "completed" : "failed";
+}

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

@@ -1,9 +1,10 @@
 import path from "node:path";
-import { GENERAL_PURPOSE_SUBAGENT, createAsyncSubAgentMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
+import { createAsyncSubAgentMiddleware, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildDeepAgentSystemPromptWithCapabilityHierarchy, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
 import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION } from "./prompts/runtime-prompts.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
@@ -21,8 +22,22 @@ export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter
 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, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+class DelegatedExecutionNoToolEvidenceError extends Error {
+    constructor(agentId) {
+        super(`Delegated agent ${agentId} completed without tool execution evidence.`);
+        this.name = "DelegatedExecutionNoToolEvidenceError";
+    }
+}
+function hasDelegatedExecutionToolEvidence(result) {
+    const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
+        ? result.metadata.executedToolResults
+        : [];
+    return executedToolResults.some((toolResult) => (toolResult.isError !== true
+        && toolResult.toolName !== "write_todos"
+        && toolResult.toolName !== "read_todos"));
+}
 function shouldUseConfigurableDeepAgentAssembly(binding) {
-    return getBindingBuiltinToolsConfig(binding) !== undefined;
+    return getBindingExecutionKind(binding) === "deepagent";
 }
 export class AgentRuntimeAdapter {
     options;
@@ -319,9 +334,18 @@ export class AgentRuntimeAdapter {
                         const childSessionId = `${sessionId}:delegated:${resolvedSubagent.name}`;
                         const childRequestId = `${requestId}:delegated:${resolvedSubagent.name}:${Date.now().toString(36)}`;
                         try {
-                            const result = await this.invoke(targetBinding, requestText, childSessionId, childRequestId, undefined, [], {
+                            const invokeOptions = {
                                 ...(typeof config?.context === "object" && config.context ? { context: config.context } : {}),
-                            });
+                            };
+                            const runDelegatedRequest = (text, requestSuffix = "") => this.invoke(targetBinding, text, childSessionId, `${childRequestId}${requestSuffix}`, undefined, [], invokeOptions);
+                            let result = await runDelegatedRequest(requestText);
+                            const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(targetBinding).length > 0;
+                            if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(result)) {
+                                result = await runDelegatedRequest([requestText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry");
+                                if (!hasDelegatedExecutionToolEvidence(result)) {
+                                    throw new DelegatedExecutionNoToolEvidenceError(targetBinding.agent.id);
+                                }
+                            }
                             return wrapRequestResultAsSubagentResponse({
                                 output: result.output,
                                 structuredResponse: result.structuredResponse,
@@ -331,9 +355,7 @@ export class AgentRuntimeAdapter {
                             const message = error instanceof Error && error.message.trim().length > 0
                                 ? error.message.trim()
                                 : "delegated execution failed";
-                            return wrapRequestResultAsSubagentResponse({
-                                output: `Blocked: ${message}`,
-                            });
+                            throw new Error(message);
                         }
                     },
                 },
@@ -422,18 +444,6 @@ export class AgentRuntimeAdapter {
             ownerId: binding.agent.id,
             skillPaths: getBindingSkills(binding),
         }) ?? [];
-        const deepAgentConfig = buildDeepAgentCreateParams({
-            binding,
-            resolvedModel,
-            resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
-            resolvedMiddleware,
-            resolvedSubagents,
-            resolvedCheckpointer,
-            resolvedStore,
-            resolvedBackend,
-            resolvedInterruptOn,
-            resolvedSkills,
-        });
         if (shouldUseConfigurableDeepAgentAssembly(binding)) {
             return this.createConfigurableDeepAgentRunnable(binding, {
                 resolvedModel,
@@ -441,36 +451,33 @@ export class AgentRuntimeAdapter {
                 resolvedMiddleware,
                 resolvedSubagents,
                 resolvedInterruptOn,
+                resolvedCheckpointer,
+                resolvedStore,
                 resolvedBackend,
                 resolvedSkills,
             });
         }
-        return createDeepAgent(deepAgentConfig);
+        throw new Error(`Agent ${binding.agent.id} has no supported deepagent assembly path`);
     }
     createConfigurableDeepAgentRunnable(binding, input) {
         const builtinTools = getBindingBuiltinToolsConfig(binding) ?? {};
         const backend = (input.resolvedBackend ?? new StateBackend({}));
         const inlineSubagents = input.resolvedSubagents.filter((subagent) => !("graphId" in subagent));
         const asyncSubagents = input.resolvedSubagents.filter((subagent) => "graphId" in subagent);
-        const subagents = inlineSubagents.some((subagent) => subagent.name === GENERAL_PURPOSE_SUBAGENT.name)
-            ? inlineSubagents
-            : [{
-                    ...GENERAL_PURPOSE_SUBAGENT,
-                    model: input.resolvedModel,
-                    tools: input.resolvedTools,
-                    skills: input.resolvedSkills,
-                }, ...inlineSubagents];
+        const subagents = inlineSubagents;
         const middleware = [
             ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
             ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({ backend, sources: input.resolvedSkills })] : []),
             ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
-            createSubAgentMiddleware({
-                defaultModel: input.resolvedModel,
-                defaultTools: input.resolvedTools,
-                defaultInterruptOn: input.resolvedInterruptOn,
-                subagents: subagents,
-                generalPurposeAgent: false,
-            }),
+            ...(subagents.length > 0
+                ? [createSubAgentMiddleware({
+                        defaultModel: input.resolvedModel,
+                        defaultTools: input.resolvedTools,
+                        defaultInterruptOn: input.resolvedInterruptOn,
+                        subagents: subagents,
+                        generalPurposeAgent: false,
+                    })]
+                : []),
             createSummarizationMiddleware({
                 model: input.resolvedModel,
                 backend,
@@ -487,10 +494,17 @@ export class AgentRuntimeAdapter {
             : undefined;
         return createAgent({
             model: input.resolvedModel,
-            systemPrompt: getBindingSystemPrompt(binding),
+            systemPrompt: buildDeepAgentSystemPromptWithCapabilityHierarchy({
+                systemPrompt: getBindingSystemPrompt(binding),
+                subagents: input.resolvedSubagents,
+                skills: input.resolvedSkills,
+                tools: getBindingPrimaryTools(binding),
+            }),
             tools: input.resolvedTools,
             middleware: middleware,
             name: binding.agent.id,
+            ...(input.resolvedCheckpointer !== undefined ? { checkpointer: input.resolvedCheckpointer } : {}),
+            ...(input.resolvedStore !== undefined ? { store: input.resolvedStore } : {}),
             ...(responseFormat !== undefined ? { responseFormat: responseFormat } : {}),
         });
     }

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

@@ -8,6 +8,16 @@ export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
     explicitToolNames?: string[];
     modelExposed?: boolean | string[];
 }): unknown[];
+export declare function buildDeepAgentSystemPromptWithCapabilityHierarchy(input: {
+    systemPrompt?: unknown;
+    subagents: Array<Pick<UpstreamSubagentConfig, "name" | "description"> | Pick<CompiledAsyncSubAgent, "name" | "description">>;
+    skills?: string[];
+    tools?: Array<{
+        name: string;
+        description?: string;
+    }>;
+}): unknown;
+export declare const buildDeepAgentSystemPromptWithSubagentCatalog: typeof buildDeepAgentSystemPromptWithCapabilityHierarchy;
 export declare function resolveRunnableCheckpointer(options: RuntimeAdapterOptions, binding: CompiledAgentBinding): unknown;
 export declare function resolveRunnableInterruptOn(binding: CompiledAgentBinding): Record<string, {
     allowedDecisions: import("./adapter/tool/interrupt-policy.js").InterruptDecision[];