@botbotgo/agent-harness 0.0.327 → 0.0.329

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

@@ -1,14 +1,109 @@
-import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
+import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
 import { projectTextStreamChunks } from "../stream-text-consumption.js";
 import { computeRemainingTimeoutMs } from "../resilience.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../upstream-configurable-keys.js";
+export class ExecutionReconciliationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ExecutionReconciliationError";
+    }
+}
 function toVisibleContent(value) {
     const extracted = extractVisibleOutput(value);
     return extracted ? sanitizeVisibleText(extracted) : "";
 }
+function readTerminalEventVisibleOutput(event) {
+    if (typeof event !== "object" || event === null) {
+        return "";
+    }
+    const typed = event;
+    const eventName = typeof typed.event === "string" ? typed.event : "";
+    if (eventName !== "on_chat_model_end" && eventName !== "on_chain_end") {
+        return "";
+    }
+    return toVisibleContent(typed.data?.output);
+}
+function hasIncompletePlanStateInExecutedToolResults(executedToolResults) {
+    for (const latest of [...executedToolResults].reverse()) {
+        if (typeof latest.output !== "object" || latest.output === null) {
+            continue;
+        }
+        const summaryContainer = latest.output.summary;
+        if (typeof summaryContainer !== "object" || summaryContainer === null) {
+            continue;
+        }
+        const summary = summaryContainer.summary;
+        if (typeof summary !== "object" || summary === null) {
+            continue;
+        }
+        const typedSummary = summary;
+        const pending = typeof typedSummary.pending === "number" ? typedSummary.pending : 0;
+        const inProgress = typeof typedSummary.inProgress === "number" ? typedSummary.inProgress : 0;
+        return pending > 0 || inProgress > 0;
+    }
+    return false;
+}
+function hasNonTodoToolEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.toolName !== "write_todos" && item.toolName !== "read_todos");
+}
+function hasSuccessfulNonTodoToolEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.isError !== true && item.toolName !== "write_todos" && item.toolName !== "read_todos");
+}
+function hasSuccessfulTaskToolEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.isError !== true && item.toolName === "task");
+}
+function buildExecutionRecoveryEvidence(params) {
+    const { projectionState, executedToolResults = [] } = params;
+    return {
+        hasToolResultEvidence: executedToolResults.length > 0 || projectionState.emittedToolResult || projectionState.emittedToolError,
+        hasSuccessfulToolResultEvidence: executedToolResults.some((item) => item.isError !== true) || projectionState.emittedSuccessfulToolResult,
+        hasNonTodoToolResultEvidence: hasNonTodoToolEvidence(executedToolResults) || projectionState.emittedNonTodoToolResult || projectionState.emittedToolError,
+        hasSuccessfulNonTodoToolResultEvidence: hasSuccessfulNonTodoToolEvidence(executedToolResults) || projectionState.emittedSuccessfulNonTodoToolResult,
+        hasIncompletePlanState: projectionState.hasIncompletePlanState || hasIncompletePlanStateInExecutedToolResults(executedToolResults),
+        hasPlanStateEvidence: projectionState.sawPlanState || hasIncompletePlanStateInExecutedToolResults(executedToolResults),
+        hasOpenTaskDelegation: projectionState.openTaskDelegations > 0,
+        hasFailedTaskDelegation: projectionState.hasFailedTaskDelegation,
+        hasDelegatedAgentWithConfiguredTools: projectionState.sawDelegatedAgentWithConfiguredTools,
+        hasDelegatedExecutionToolEvidence: projectionState.emittedDelegatedExecutionToolResult,
+        hasOnlyPlaceholderTaskCompletion: projectionState.emittedSuccessfulTaskResult
+            && projectionState.emittedPlaceholderTaskResult
+            && !projectionState.emittedDelegatedTerminalOutput,
+    };
+}
+function hasUnresolvedExecution(evidence) {
+    return (evidence.hasIncompletePlanState
+        || evidence.hasFailedTaskDelegation
+        || evidence.hasOpenTaskDelegation);
+}
+function hasMissingDelegatedExecutionEvidence(evidence) {
+    return evidence.hasDelegatedAgentWithConfiguredTools && !evidence.hasDelegatedExecutionToolEvidence;
+}
+function hasMissingDelegatedFindings(evidence) {
+    return evidence.hasDelegatedAgentWithConfiguredTools && evidence.hasOnlyPlaceholderTaskCompletion;
+}
+function createUnresolvedExecutionError(evidence) {
+    const reasons = [];
+    if (evidence.hasIncompletePlanState) {
+        reasons.push("plan state still has unfinished work");
+    }
+    if (evidence.hasFailedTaskDelegation) {
+        reasons.push("delegated task failed before surfacing final findings");
+    }
+    if (evidence.hasOpenTaskDelegation) {
+        reasons.push("delegated task has not finished");
+    }
+    if (hasMissingDelegatedExecutionEvidence(evidence)) {
+        reasons.push("delegated agent ended without surfacing any real tool execution evidence");
+    }
+    if (hasMissingDelegatedFindings(evidence)) {
+        reasons.push("delegated task returned only the upstream placeholder result without surfaced final findings");
+    }
+    const detail = reasons.length > 0 ? `: ${reasons.join("; ")}` : "";
+    return new ExecutionReconciliationError(`Agent ended before execution was fully reconciled${detail}.`);
+}
 function createProfileStep(id, kind, name, action, status, detail) {
     return {
         kind: "profile",
@@ -49,6 +144,7 @@ export async function* streamRuntimeExecution(options) {
     const shouldValidateStreamOutput = shouldValidateExecutionWithoutToolEvidence(request);
     const deferredStreamContent = [];
     let sawRetrySafeInvalidToolSelectionError = false;
+    const projectionState = createStreamEventProjectionState();
     const shouldDeferStreamContent = () => shouldValidateStreamOutput && !emittedUnsafeStreamSideEffects;
     const flushDeferredStreamContent = async function* () {
         while (deferredStreamContent.length > 0) {
@@ -212,7 +308,6 @@ export async function* streamRuntimeExecution(options) {
                     });
                 throw error;
             }
-            const projectionState = createStreamEventProjectionState();
             const streamEventsConsume = startProfileStep({
                 id: "profile:agent:stream-events-consume",
                 kind: "agent",
@@ -225,8 +320,12 @@ export async function* streamRuntimeExecution(options) {
                 for await (const event of options.iterateWithTimeout(events, options.streamIdleTimeoutMs, "agent streamEvents", options.streamDeadlineAt, options.invokeTimeoutMs)) {
                     const projectedChunks = projectRuntimeStreamEvent({
                         event,
-                        allowVisibleStreamDeltas: options.isLangChainBinding(options.binding),
+                        allowVisibleStreamDeltas: true,
                         includeStateStreamOutput: options.isDeepAgentBinding(options.binding),
+                        rootAgentId: typeof options.binding.agent?.id === "string"
+                            ? options.binding.agent.id
+                            : undefined,
+                        countConfiguredToolsForAgentId: options.countConfiguredToolsForAgentId,
                         toolNameMapping: options.toolNameMapping,
                         primaryTools: options.primaryTools,
                         state: projectionState,
@@ -248,12 +347,27 @@ export async function* streamRuntimeExecution(options) {
                         if (eventContainsNonTodoToolResult || eventContainsNonRetrySafeChunk) {
                             emittedUnsafeStreamSideEffects = true;
                         }
-                        if (chunk.kind === "content" && shouldDeferStreamContent()) {
+                        if (chunk.kind === "content" && (shouldDeferStreamContent() || projectionState.hasFailedTaskDelegation)) {
                             deferredStreamContent.push(chunk);
                             continue;
                         }
                         yield chunk;
                     }
+                    const terminalVisibleOutput = readTerminalEventVisibleOutput(event);
+                    if (terminalVisibleOutput) {
+                        const terminalExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
+                        if (!shouldDeferStreamContent()
+                            && !terminalExecutionEvidence.hasIncompletePlanState
+                            && !terminalExecutionEvidence.hasFailedTaskDelegation
+                            && !terminalExecutionEvidence.hasOpenTaskDelegation
+                            && !hasMissingDelegatedExecutionEvidence(terminalExecutionEvidence)
+                            && !hasMissingDelegatedFindings(terminalExecutionEvidence)) {
+                            if (deferredStreamContent.length > 0) {
+                                yield* flushDeferredStreamContent();
+                            }
+                            return;
+                        }
+                    }
                 }
                 if (shouldProfile)
                     yield finishProfileStep({
@@ -278,13 +392,55 @@ export async function* streamRuntimeExecution(options) {
                     });
                 throw error;
             }
-            const terminalRecoveryInstruction = !emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION : null;
-            if (terminalRecoveryInstruction) {
+            const streamedExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
+            if (hasUnresolvedExecution(streamedExecutionEvidence)) {
+                throw createUnresolvedExecutionError(streamedExecutionEvidence);
+            }
+            const executionWithoutToolEvidenceInstruction = projectionState.emittedOutput
+                ? resolveExecutionWithoutToolEvidenceTextInstruction(request, projectionState.emittedOutput, false, {
+                    ...streamedExecutionEvidence,
+                    hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(streamedExecutionEvidence),
+                })
+                : null;
+            const retryInstruction = !emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError
+                ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION
+                : executionWithoutToolEvidenceInstruction;
+            if (retryInstruction) {
                 let retried;
-                retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, terminalRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
+                retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, retryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
                 const executedToolResults = Array.isArray(retried.metadata?.executedToolResults)
                     ? retried.metadata.executedToolResults
                     : [];
+                const originalExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
+                const retriedExecutionEvidence = buildExecutionRecoveryEvidence({
+                    projectionState: createStreamEventProjectionState(),
+                    executedToolResults,
+                });
+                const retriedVisibleOutput = retried.output ? toVisibleContent(retried.output) : "";
+                const retriedCarriesExecutionEvidence = retriedExecutionEvidence.hasToolResultEvidence
+                    || retriedExecutionEvidence.hasOpenTaskDelegation
+                    || retriedExecutionEvidence.hasDelegatedExecutionToolEvidence;
+                const retriedHasUnresolvedExecution = hasUnresolvedExecution(retriedExecutionEvidence)
+                    || hasMissingDelegatedExecutionEvidence(retriedExecutionEvidence)
+                    || hasMissingDelegatedFindings(retriedExecutionEvidence)
+                    || (!retriedCarriesExecutionEvidence
+                        && (hasUnresolvedExecution(originalExecutionEvidence)
+                            || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
+                            || hasMissingDelegatedFindings(originalExecutionEvidence)));
+                const effectiveRecoveryEvidence = retriedCarriesExecutionEvidence
+                    ? retriedExecutionEvidence
+                    : {
+                        ...retriedExecutionEvidence,
+                        hasIncompletePlanState: originalExecutionEvidence.hasIncompletePlanState,
+                        hasFailedTaskDelegation: originalExecutionEvidence.hasFailedTaskDelegation,
+                        hasOpenTaskDelegation: originalExecutionEvidence.hasOpenTaskDelegation,
+                        hasDelegatedAgentWithConfiguredTools: originalExecutionEvidence.hasDelegatedAgentWithConfiguredTools,
+                        hasDelegatedExecutionToolEvidence: originalExecutionEvidence.hasDelegatedExecutionToolEvidence,
+                    };
+                if (retriedHasUnresolvedExecution
+                    || (retriedHasUnresolvedExecution && retriedExecutionEvidence.hasToolResultEvidence && !retriedVisibleOutput)) {
+                    throw createUnresolvedExecutionError(effectiveRecoveryEvidence);
+                }
                 for (const toolResult of executedToolResults) {
                     yield {
                         kind: "tool-result",
@@ -303,7 +459,15 @@ export async function* streamRuntimeExecution(options) {
             if (deferredStreamContent.length > 0) {
                 yield* flushDeferredStreamContent();
             }
-            if (projectionState.emittedOutput || projectionState.emittedToolResult || projectionState.emittedToolError) {
+            if (hasMissingDelegatedExecutionEvidence(streamedExecutionEvidence)) {
+                throw createUnresolvedExecutionError(streamedExecutionEvidence);
+            }
+            if (hasMissingDelegatedFindings(streamedExecutionEvidence)) {
+                throw createUnresolvedExecutionError(streamedExecutionEvidence);
+            }
+            const hasUnresolvedStreamExecution = hasUnresolvedExecution(streamedExecutionEvidence);
+            if (projectionState.emittedOutput
+                || ((projectionState.emittedToolResult || projectionState.emittedToolError) && !hasUnresolvedStreamExecution)) {
                 return;
             }
         }
@@ -429,6 +593,73 @@ export async function* streamRuntimeExecution(options) {
         const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
             ? result.metadata.executedToolResults
             : [];
+        const invokeExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState, executedToolResults });
+        if (hasUnresolvedExecution(invokeExecutionEvidence)) {
+            throw createUnresolvedExecutionError(invokeExecutionEvidence);
+        }
+        const invokeFallbackRecoveryInstruction = result.output
+            ? resolveExecutionWithoutToolEvidenceTextInstruction(request, result.output, false, {
+                ...invokeExecutionEvidence,
+                hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(invokeExecutionEvidence),
+            })
+            : null;
+        if (invokeFallbackRecoveryInstruction) {
+            const recovered = await options.invoke(options.applyToolRecoveryInstruction(options.binding, invokeFallbackRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
+            const recoveredToolResults = Array.isArray(recovered.metadata?.executedToolResults)
+                ? recovered.metadata.executedToolResults
+                : [];
+            const originalExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState, executedToolResults });
+            const recoveredExecutionEvidence = buildExecutionRecoveryEvidence({
+                projectionState: createStreamEventProjectionState(),
+                executedToolResults: recoveredToolResults,
+            });
+            const recoveredVisibleOutput = recovered.output ? toVisibleContent(recovered.output) : "";
+            const recoveredCarriesExecutionEvidence = recoveredExecutionEvidence.hasToolResultEvidence
+                || recoveredExecutionEvidence.hasOpenTaskDelegation
+                || recoveredExecutionEvidence.hasDelegatedExecutionToolEvidence;
+            const recoveredHasUnresolvedExecution = hasUnresolvedExecution(recoveredExecutionEvidence)
+                || hasMissingDelegatedExecutionEvidence(recoveredExecutionEvidence)
+                || hasMissingDelegatedFindings(recoveredExecutionEvidence)
+                || (!recoveredCarriesExecutionEvidence
+                    && (hasUnresolvedExecution(originalExecutionEvidence)
+                        || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
+                        || hasMissingDelegatedFindings(originalExecutionEvidence)));
+            const effectiveRecoveredEvidence = recoveredCarriesExecutionEvidence
+                ? recoveredExecutionEvidence
+                : {
+                    ...recoveredExecutionEvidence,
+                    hasIncompletePlanState: originalExecutionEvidence.hasIncompletePlanState,
+                    hasFailedTaskDelegation: originalExecutionEvidence.hasFailedTaskDelegation,
+                    hasOpenTaskDelegation: originalExecutionEvidence.hasOpenTaskDelegation,
+                    hasDelegatedAgentWithConfiguredTools: originalExecutionEvidence.hasDelegatedAgentWithConfiguredTools,
+                    hasDelegatedExecutionToolEvidence: originalExecutionEvidence.hasDelegatedExecutionToolEvidence,
+                };
+            if (recoveredHasUnresolvedExecution
+                || (recoveredHasUnresolvedExecution && recoveredExecutionEvidence.hasToolResultEvidence && !recoveredVisibleOutput)) {
+                throw createUnresolvedExecutionError(effectiveRecoveredEvidence);
+            }
+            for (const toolResult of recoveredToolResults) {
+                yield {
+                    kind: "tool-result",
+                    toolName: toolResult.toolName,
+                    output: toolResult.output,
+                    isError: toolResult.isError,
+                };
+            }
+            if (recovered.output) {
+                const visible = toVisibleContent(recovered.output);
+                if (visible) {
+                    yield { kind: "content", content: visible };
+                }
+            }
+            return;
+        }
+        if (hasMissingDelegatedExecutionEvidence(invokeExecutionEvidence)) {
+            throw createUnresolvedExecutionError(invokeExecutionEvidence);
+        }
+        if (hasMissingDelegatedFindings(invokeExecutionEvidence)) {
+            throw createUnresolvedExecutionError(invokeExecutionEvidence);
+        }
         for (const toolResult of executedToolResults) {
             yield {
                 kind: "tool-result",

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

@@ -4,7 +4,42 @@ 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, resolveExecutionWithoutToolEvidenceTextInstruction, sanitizeVisibleText, } from "../parsing/output-parsing.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) {
+    if (typeof output !== "object" || output === null) {
+        return null;
+    }
+    const typed = output;
+    const summaryContainer = typed.summary;
+    if (typeof summaryContainer !== "object" || summaryContainer === null) {
+        return null;
+    }
+    const nested = summaryContainer;
+    const counts = nested.summary;
+    if (typeof counts !== "object" || counts === null) {
+        return null;
+    }
+    const typedCounts = counts;
+    return {
+        pending: typeof typedCounts.pending === "number" ? typedCounts.pending : 0,
+        inProgress: typeof typedCounts.inProgress === "number" ? typedCounts.inProgress : 0,
+    };
+}
+function hasIncompleteExecutedPlan(executedToolResults) {
+    for (const latest of [...executedToolResults].reverse()) {
+        const summary = readPlanStateSummary(latest.output);
+        if (!summary) {
+            continue;
+        }
+        return summary.pending > 0 || summary.inProgress > 0;
+    }
+    return false;
+}
+function hasNonTodoToolEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.toolName !== "write_todos" && item.toolName !== "read_todos");
+}
 function extractLatestUserInput(request) {
     const typedRequest = request;
     const messages = Array.isArray(typedRequest.messages) ? typedRequest.messages : [];
@@ -40,6 +75,24 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
         pendingResult = undefined;
         const toolCalls = extractToolCallsFromResult(result);
         if (toolCalls.length === 0) {
+            const terminalText = sanitizeVisibleText(extractVisibleOutput(result) || "");
+            const hasIncompletePlanState = hasIncompleteExecutedPlan(executedToolResults);
+            const hasExecutionBeyondTodoPlanning = hasNonTodoToolEvidence(executedToolResults);
+            const recoveryInstruction = terminalText
+                ? resolveExecutionWithoutToolEvidenceTextInstruction(activeRequest, terminalText, false, {
+                    hasToolResultEvidence: hasExecutionBeyondTodoPlanning,
+                    hasIncompletePlanState: hasExecutionBeyondTodoPlanning && hasIncompletePlanState,
+                })
+                : hasIncompletePlanState && hasExecutionBeyondTodoPlanning
+                    ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
+                    : null;
+            if (recoveryInstruction) {
+                if (iteration + 1 === maxToolIterations) {
+                    throw new Error(`Tool-calling loop exceeded the maximum of ${maxToolIterations} iterations`);
+                }
+                activeRequest = appendToolRecoveryInstruction(activeRequest, recoveryInstruction);
+                continue;
+            }
             break;
         }
         if (!canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools)) {

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

@@ -1,4 +1,4 @@
-import { HumanMessage } from "@langchain/core/messages";
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware } from "langchain";
 import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
@@ -7,9 +7,98 @@ import { extractToolFallbackContext, extractVisibleOutput } from "../parsing/out
 import { isRecord } from "../../utils/object.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
-import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
-import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
+import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, 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 { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION } from "../prompts/runtime-prompts.js";
+import { createStreamEventProjectionState, projectRuntimeStreamEvent } from "./stream-event-projection.js";
+const EMPTY_TOOL_NAME_MAPPING = {
+    originalToModelFacing: new Map(),
+    modelFacingToOriginal: new Map(),
+};
+function readPlanStateSummaryCounts(summary) {
+    if (typeof summary !== "object" || summary === null) {
+        return null;
+    }
+    const typed = summary;
+    const hasAny = typeof typed.pending === "number"
+        || typeof typed.inProgress === "number";
+    if (!hasAny) {
+        return null;
+    }
+    return {
+        pending: typeof typed.pending === "number" ? typed.pending : 0,
+        inProgress: typeof typed.inProgress === "number" ? typed.inProgress : 0,
+    };
+}
+function hasIncompletePlanTodos(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.some((item) => {
+        if (typeof item !== "object" || item === null) {
+            return false;
+        }
+        const status = item.status;
+        return status === "pending" || status === "in_progress";
+    });
+}
+function hasIncompletePlanStateInValue(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => hasIncompletePlanStateInValue(item));
+    }
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const typed = value;
+    const summaryCounts = readPlanStateSummaryCounts(typed.summary);
+    if (summaryCounts) {
+        return summaryCounts.pending > 0 || summaryCounts.inProgress > 0;
+    }
+    const todoCompleteness = hasIncompletePlanTodos(typed.todos);
+    if (todoCompleteness !== null) {
+        return todoCompleteness;
+    }
+    const nestedCandidates = [
+        typed.summary,
+        typed.output,
+        typed.content,
+        typed.update,
+        typed.data,
+        typed.messages,
+    ];
+    return nestedCandidates.some((candidate) => hasIncompletePlanStateInValue(candidate));
+}
+function hasUnresolvedDelegatedExecution(state) {
+    return state.hasIncompletePlanState || state.openTaskDelegations > 0;
+}
+function hasMissingDelegatedToolExecutionEvidence(state, subagentHasTools) {
+    return subagentHasTools && !state.emittedToolResult && !state.emittedToolError;
+}
+function formatDelegatedExecutionBlocker(state) {
+    const summary = state.emittedOutput.trim();
+    if (summary) {
+        return summary;
+    }
+    if (state.emittedToolError) {
+        return "Delegated investigation encountered a tool failure before the plan completed.";
+    }
+    if (state.openTaskDelegations > 0) {
+        return "Delegated investigation did not finish before control returned to the parent agent.";
+    }
+    return "Delegated investigation ended before the plan was completed.";
+}
+function requiresDelegatedExecutionRecovery(state) {
+    return hasUnresolvedDelegatedExecution(state) || (state.emittedToolResult && !state.emittedOutput.trim());
+}
+const DELEGATED_FAILURE_PLAN_RECONCILIATION_INSTRUCTION = [
+    "Your previous attempt ended with a tool failure while the todo board still had unfinished work.",
+    "Do not continue broad investigation from here.",
+    "If the failed command had malformed arguments you can correct locally, retry that same command once.",
+    "Otherwise, if a todo board already exists, call write_todos again and keep only the tasks that were actually completed in this session.",
+    "Remove the unfinished tasks that cannot proceed until the blocker is resolved.",
+    "Then return a concise blocker report.",
+].join(" ");
 export function buildBuiltinTaskSubagentMiddleware(input) {
     const { selectedSubagent, builtinBackend, summarizationModel } = input;
     const defaultSubagentMiddleware = [
@@ -57,13 +146,6 @@ function buildLangChainContextMiddleware(params) {
     }
     return middleware;
 }
-function resolveLangChainDelegationCompatibility(params) {
-    return applyDeepAgentDelegationPromptCompatibility(params.model, {
-        subagents: params.subagents,
-        generalPurposeAgent: params.generalPurposeAgent,
-        taskDescription: params.taskDescription,
-    });
-}
 export function planLangChainRuntimeExtensions(binding) {
     const primaryModel = getBindingPrimaryModel(binding);
     if (!isLangChainBinding(binding) || !primaryModel) {
@@ -71,12 +153,6 @@ export function planLangChainRuntimeExtensions(binding) {
     }
     const skills = getBindingSkills(binding);
     const memory = getBindingMemorySources(binding);
-    const delegationCompatibility = resolveLangChainDelegationCompatibility({
-        model: primaryModel,
-        subagents: getBindingSubagents(binding),
-        generalPurposeAgent: getBindingGeneralPurposeAgent(binding),
-        taskDescription: getBindingTaskDescription(binding),
-    });
     return {
         includePatchToolCalls: !bindingHasMiddlewareKind(binding, "patchToolCalls"),
         includeAutomaticSummarization: !bindingHasMiddlewareKind(binding, "summarization"),
@@ -86,9 +162,9 @@ export function planLangChainRuntimeExtensions(binding) {
         },
         delegation: bindingHasLangChainSubagentSupport(binding)
             ? {
-                subagents: delegationCompatibility.subagents ?? [],
-                generalPurposeAgent: delegationCompatibility.generalPurposeAgent,
-                taskDescription: delegationCompatibility.taskDescription,
+                subagents: getBindingSubagents(binding),
+                generalPurposeAgent: getBindingGeneralPurposeAgent(binding),
+                taskDescription: getBindingTaskDescription(binding),
                 interruptOn: getBindingInterruptCompatibilityRules(binding),
             }
             : undefined,
@@ -142,13 +218,18 @@ export async function invokeBuiltinTaskTool(input) {
     }
     const primaryModel = getBindingPrimaryModel(input.binding);
     const primaryTools = getBindingPrimaryTools(input.binding);
-    const compiledSubagents = getBindingSubagents(input.binding);
+    const compiledSubagents = getBindingDeepAgentSubagents(input.binding)
+        .filter((subagent) => !("graphId" in subagent));
     if (!primaryModel) {
         throw new Error(`Agent ${input.binding.agent.id} has no deepagent params`);
     }
     const typedInput = isRecord(input.toolInput) ? input.toolInput : {};
-    const description = typeof typedInput.description === "string" ? typedInput.description : "";
-    const subagentType = typeof typedInput.subagent_type === "string" ? typedInput.subagent_type : "";
+    const description = typeof typedInput.description === "string"
+        ? typedInput.description
+        : "";
+    const subagentType = typeof typedInput.subagent_type === "string"
+        ? typedInput.subagent_type
+        : "";
     const builtinBackend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
     const resolvedSubagents = await input.resolveSubagents(compiledSubagents, input.binding);
     const selectedSubagent = resolvedSubagents.find((subagent) => subagent.name === subagentType);
@@ -163,16 +244,82 @@ export async function invokeBuiltinTaskTool(input) {
         builtinBackend,
         summarizationModel,
     });
+    const resolvedSubagentTools = selectedSubagent.tools ?? input.resolveTools(primaryTools, input.binding);
+    const subagentHasTools = (resolvedSubagentTools?.length ?? 0) > 0;
     const runnable = createAgent({
         model: (selectedSubagent.model ?? resolvedHostModel),
-        tools: (selectedSubagent.tools ?? input.resolveTools(primaryTools, input.binding)),
+        tools: resolvedSubagentTools,
         systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
         middleware: middleware,
         responseFormat: selectedSubagent.responseFormat,
         name: selectedSubagent.name,
         description: selectedSubagent.description,
     });
-    const result = await runnable.invoke({ messages: [new HumanMessage({ content: description })] }, { configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: `${input.binding.agent.id}:builtin-task` }, ...(input.options?.context ? { context: input.options.context } : {}) });
+    const invokeConfig = {
+        configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: `${input.binding.agent.id}:builtin-task` },
+        ...(input.options?.context ? { context: input.options.context } : {}),
+    };
+    const buildMessages = (recoveryInstruction) => ({
+        messages: [
+            ...(recoveryInstruction ? [new SystemMessage({ content: recoveryInstruction })] : []),
+            new HumanMessage({ content: description }),
+        ],
+    });
+    if (typeof runnable.streamEvents === "function") {
+        const runWithStreamInspection = async (recoveryInstruction) => {
+            const projectionState = createStreamEventProjectionState();
+            const events = await runnable.streamEvents(buildMessages(recoveryInstruction), invokeConfig);
+            for await (const event of events) {
+                projectRuntimeStreamEvent({
+                    event,
+                    allowVisibleStreamDeltas: false,
+                    includeStateStreamOutput: false,
+                    rootAgentId: input.binding.agent.id,
+                    countConfiguredToolsForAgentId: (agentId) => agentId === selectedSubagent.name ? resolvedSubagentTools.length : 0,
+                    toolNameMapping: EMPTY_TOOL_NAME_MAPPING,
+                    primaryTools: [],
+                    state: projectionState,
+                });
+            }
+            return projectionState;
+        };
+        let projectionState = await runWithStreamInspection();
+        if (requiresDelegatedExecutionRecovery(projectionState)) {
+            const recoveryInstruction = projectionState.hasIncompletePlanState && projectionState.emittedToolError
+                ? `${AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION}\n\n${DELEGATED_FAILURE_PLAN_RECONCILIATION_INSTRUCTION}`
+                : AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION;
+            projectionState = await runWithStreamInspection(recoveryInstruction);
+        }
+        if (requiresDelegatedExecutionRecovery(projectionState)) {
+            throw new Error(formatDelegatedExecutionBlocker(projectionState));
+        }
+        if (hasMissingDelegatedToolExecutionEvidence(projectionState, subagentHasTools)) {
+            throw new Error("Delegated investigation ended without any real tool execution evidence.");
+        }
+        if (projectionState.emittedToolError) {
+            const blockerMessage = projectionState.emittedOutput.trim()
+                || formatDelegatedExecutionBlocker(projectionState);
+            if (hasUnresolvedDelegatedExecution(projectionState) || !projectionState.emittedSuccessfulToolResult) {
+                throw new Error(blockerMessage);
+            }
+        }
+        if (projectionState.emittedOutput.trim()) {
+            return projectionState.emittedOutput.trim();
+        }
+        if (projectionState.emittedToolResult) {
+            throw new Error("Delegated investigation performed tool work but did not return surfaced findings.");
+        }
+    }
+    let result = await runnable.invoke(buildMessages(), invokeConfig);
+    if (hasIncompletePlanStateInValue(result)) {
+        result = await runnable.invoke(buildMessages(AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION), invokeConfig);
+    }
+    if (hasIncompletePlanStateInValue(result)) {
+        throw new Error(extractVisibleOutput(result) || extractToolFallbackContext(result) || "Delegated investigation ended before the plan was completed.");
+    }
+    if (subagentHasTools) {
+        throw new Error("Delegated investigation ended without any real tool execution evidence.");
+    }
     const visibleOutput = extractVisibleOutput(result);
     const fallbackOutput = extractToolFallbackContext(result);
     return visibleOutput || fallbackOutput || JSON.stringify(result);
@@ -180,12 +327,10 @@ export async function invokeBuiltinTaskTool(input) {
 export async function resolveBuiltinMiddlewareTools(input) {
     const backend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
     return createBuiltinMiddlewareTools(backend, {
-        includeTaskTool: isDeepAgentBinding(input.binding),
+        includeTaskTool: false,
         workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
         toolRuntimeContext: input.options?.toolRuntimeContext,
-        invokeTaskTool: isDeepAgentBinding(input.binding)
-            ? async (toolInput) => input.invokeBuiltinTaskTool(input.binding, toolInput, input.options)
-            : undefined,
+        invokeTaskTool: undefined,
     });
 }
 export async function materializeAutomaticSummarizationMiddleware(input) {
@@ -214,7 +359,7 @@ export async function materializeLangChainRuntimeMiddleware(input) {
         memory: input.plan.context.memory,
         resolveFilesystemBackend: input.resolveFilesystemBackend,
     }));
-    if (input.plan.delegation) {
+    if (input.plan.delegation && !isDeepAgentBinding(input.binding)) {
         runtimeMiddleware.push(createSubAgentMiddleware({
             defaultModel: (await input.resolveModel(primaryModel)),
             defaultTools: input.resolveTools(primaryTools, input.binding),