@botbotgo/agent-harness 0.0.338 → 0.0.341

package/dist/contracts/workspace.d.ts

@@ -174,6 +174,7 @@ export type CompiledTool = {
     };
 };
 export type CompiledSubAgent = {
+    agentId?: string;
     name: string;
     description: string;
     systemPrompt: string;
@@ -183,6 +184,10 @@ export type CompiledSubAgent = {
     skills?: string[];
     responseFormat?: unknown;
     middleware?: Array<Record<string, unknown>>;
+    builtinTools?: {
+        filesystem?: boolean;
+        todos?: boolean;
+    };
 };
 export type CompiledAsyncSubAgent = {
     name: string;
@@ -219,6 +224,11 @@ export type DeepAgentParams = {
     name: string;
     memory: string[];
     skills: string[];
+    interactionMode?: "stream" | "invoke";
+    builtinTools?: {
+        filesystem?: boolean;
+        todos?: boolean;
+    };
 };
 export type LegacyLangChainAgentParams = LangChainAgentParams & {
     passthrough?: Record<string, unknown>;

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.337";
-export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-23";
+export declare const AGENT_HARNESS_VERSION = "0.0.341";
+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.337";
-export const AGENT_HARNESS_RELEASE_DATE = "2026-04-23";
+export const AGENT_HARNESS_VERSION = "0.0.341";
+export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/runtime/adapter/flow/execution-context.js

@@ -1,5 +1,5 @@
 import { buildExecutableToolMap } from "../tool-resolution.js";
-import { getBindingPrimaryModel, getBindingPrimaryTools, isLangChainBinding } from "../../support/compiled-binding.js";
+import { getBindingInteractionMode, getBindingPrimaryModel, getBindingPrimaryTools, isLangChainBinding } from "../../support/compiled-binding.js";
 export function buildBindingToolCatalog(input) {
     const primaryTools = getBindingPrimaryTools(input.binding);
     const toolNameMapping = input.getToolNameMapping(input.binding);
@@ -54,6 +54,7 @@ export async function resolveRuntimeStreamExecutionContext(input) {
         binding: input.binding,
         getToolNameMapping: input.getToolNameMapping,
     });
+    const interactionMode = getBindingInteractionMode(input.binding) ?? "stream";
     const { forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveLangChainStreamContext({
         binding: input.binding,
         resolveModel: input.resolveModel,
@@ -62,7 +63,7 @@ export async function resolveRuntimeStreamExecutionContext(input) {
     return {
         primaryTools,
         toolNameMapping,
-        forceInvokeFallback,
+        forceInvokeFallback: interactionMode === "invoke" ? true : forceInvokeFallback,
         canUseDirectModelStream,
         langChainStreamModel,
     };

package/dist/runtime/adapter/flow/stream-runtime.d.ts

@@ -30,6 +30,12 @@ export declare function streamRuntimeExecution(options: {
         stream?: (input: unknown) => Promise<AsyncIterable<unknown>>;
     };
     createRunnable: () => Promise<RunnableLike>;
+    resolveInvocationConfig?: (binding: CompiledAgentBinding, options: {
+        sessionId: string;
+        requestId: string;
+        context?: Record<string, unknown>;
+        toolRuntimeContext?: Record<string, unknown>;
+    }) => Record<string, unknown>;
     withTimeout: <T>(producer: () => T | Promise<T>, timeoutMs: number | undefined, operation: string, stage?: "stream" | "invoke") => Promise<T>;
     iterateWithTimeout: <T>(iterable: AsyncIterable<T>, timeoutMs: number | undefined, operation: string, deadlineAt?: number, deadlineTimeoutMs?: number) => AsyncGenerator<T>;
     invokeTimeoutMs?: number;

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

@@ -1,4 +1,4 @@
-import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
+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 { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
@@ -152,6 +152,22 @@ export async function* streamRuntimeExecution(options) {
     const deferredStreamContent = [];
     let sawRetrySafeInvalidToolSelectionError = false;
     const projectionState = createStreamEventProjectionState();
+    const requestId = options.runtimeOptions.requestId ?? options.sessionId;
+    const buildRunnableConfig = (extra) => ({
+        ...(options.resolveInvocationConfig
+            ? options.resolveInvocationConfig(options.binding, {
+                sessionId: options.sessionId,
+                requestId,
+                ...(options.runtimeOptions.context ? { context: options.runtimeOptions.context } : {}),
+                ...(options.runtimeOptions.toolRuntimeContext ? { toolRuntimeContext: options.runtimeOptions.toolRuntimeContext } : {}),
+            })
+            : {
+                configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId, [UPSTREAM_REQUEST_CONFIG_KEY]: requestId },
+                ...(options.runtimeOptions.context ? { context: options.runtimeOptions.context } : {}),
+                ...(options.runtimeOptions.toolRuntimeContext ? { toolRuntimeContext: options.runtimeOptions.toolRuntimeContext } : {}),
+            }),
+        ...(extra ?? {}),
+    });
     const shouldDeferStreamContent = () => shouldValidateStreamOutput && !emittedUnsafeStreamSideEffects;
     const flushDeferredStreamContent = async function* () {
         while (deferredStreamContent.length > 0) {
@@ -293,12 +309,7 @@ export async function* streamRuntimeExecution(options) {
                 yield streamEventsStart.chunk;
             let events;
             try {
-                events = await options.withTimeout(() => runnable.streamEvents(request, {
-                    configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId, [UPSTREAM_REQUEST_CONFIG_KEY]: options.runtimeOptions.requestId },
-                    version: "v2",
-                    ...(options.runtimeOptions.context ? { context: options.runtimeOptions.context } : {}),
-                    ...(options.runtimeOptions.toolRuntimeContext ? { toolRuntimeContext: options.runtimeOptions.toolRuntimeContext } : {}),
-                }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent streamEvents start", "stream");
+                events = await options.withTimeout(() => runnable.streamEvents(request, buildRunnableConfig({ version: "v2" })), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent streamEvents start", "stream");
                 if (shouldProfile)
                     yield finishProfileStep({
                         id: "profile:agent:stream-events-start",
@@ -370,12 +381,24 @@ export async function* streamRuntimeExecution(options) {
                     const terminalVisibleOutput = readTerminalEventVisibleOutput(event);
                     if (terminalVisibleOutput) {
                         const terminalExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
+                        const terminalMissingPlanRecoveryInstruction = !terminalExecutionEvidence.hasDelegatedAgentWithConfiguredTools
+                            && !terminalExecutionEvidence.hasOpenTaskDelegation
+                            && !projectionState.emittedSuccessfulTaskResult
+                            ? resolveMissingPlanRecoveryInstruction({
+                                request,
+                                assistantText: terminalVisibleOutput,
+                                hasPlanStateEvidence: terminalExecutionEvidence.hasPlanStateEvidence,
+                                hasWriteTodosEvidence: terminalExecutionEvidence.hasPlanStateEvidence,
+                                hasToolResultEvidence: terminalExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
+                            })
+                            : null;
                         if (!shouldDeferStreamContent()
                             && !terminalExecutionEvidence.hasIncompletePlanState
                             && !terminalExecutionEvidence.hasFailedTaskDelegation
                             && !terminalExecutionEvidence.hasOpenTaskDelegation
                             && !hasMissingDelegatedExecutionEvidence(terminalExecutionEvidence)
-                            && !hasMissingDelegatedFindings(terminalExecutionEvidence)) {
+                            && !hasMissingDelegatedFindings(terminalExecutionEvidence)
+                            && !terminalMissingPlanRecoveryInstruction) {
                             if (deferredStreamContent.length > 0) {
                                 yield* flushDeferredStreamContent();
                             }
@@ -419,9 +442,18 @@ export async function* streamRuntimeExecution(options) {
                     hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(streamedExecutionEvidence),
                 })
                 : null;
+            const missingPlanRecoveryInstruction = !hasUnresolvedExecution(streamedExecutionEvidence) && !delegatedExecutionRecoveryInstruction
+                ? resolveMissingPlanRecoveryInstruction({
+                    request,
+                    assistantText: projectionState.emittedOutput,
+                    hasPlanStateEvidence: streamedExecutionEvidence.hasPlanStateEvidence,
+                    hasWriteTodosEvidence: streamedExecutionEvidence.hasPlanStateEvidence,
+                    hasToolResultEvidence: streamedExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
+                })
+                : null;
             const retryInstruction = !emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError
                 ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION
-                : delegatedExecutionRecoveryInstruction ?? executionWithoutToolEvidenceInstruction;
+                : delegatedExecutionRecoveryInstruction ?? missingPlanRecoveryInstruction ?? executionWithoutToolEvidenceInstruction;
             if (retryInstruction) {
                 let retried;
                 retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, retryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
@@ -499,10 +531,7 @@ export async function* streamRuntimeExecution(options) {
                 yield streamStart.chunk;
             let stream;
             try {
-                stream = await options.withTimeout(() => runnable.stream(request, {
-                    configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId, [UPSTREAM_REQUEST_CONFIG_KEY]: options.runtimeOptions.requestId },
-                    ...(options.runtimeOptions.toolRuntimeContext ? { toolRuntimeContext: options.runtimeOptions.toolRuntimeContext } : {}),
-                }), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent stream start", "stream");
+                stream = await options.withTimeout(() => runnable.stream(request, buildRunnableConfig()), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "agent stream start", "stream");
                 if (shouldProfile)
                     yield finishProfileStep({
                         id: "profile:agent:stream-start",
@@ -620,8 +649,18 @@ export async function* streamRuntimeExecution(options) {
                 hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(invokeExecutionEvidence),
             })
             : resolveDelegatedExecutionRecoveryInstruction(invokeExecutionEvidence);
-        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 invokeFallbackMissingPlanRecoveryInstruction = !hasUnresolvedExecution(invokeExecutionEvidence) && !invokeFallbackRecoveryInstruction
+            ? resolveMissingPlanRecoveryInstruction({
+                request,
+                assistantText: typeof result.output === "string" ? result.output : "",
+                hasPlanStateEvidence: invokeExecutionEvidence.hasPlanStateEvidence,
+                hasWriteTodosEvidence: invokeExecutionEvidence.hasPlanStateEvidence,
+                hasToolResultEvidence: invokeExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
+            })
+            : null;
+        const effectiveInvokeFallbackRecoveryInstruction = invokeFallbackMissingPlanRecoveryInstruction ?? invokeFallbackRecoveryInstruction;
+        if (effectiveInvokeFallbackRecoveryInstruction) {
+            const recovered = await options.invoke(options.applyToolRecoveryInstruction(options.binding, effectiveInvokeFallbackRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
             const recoveredToolResults = Array.isArray(recovered.metadata?.executedToolResults)
                 ? recovered.metadata.executedToolResults
                 : [];

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

@@ -2,6 +2,7 @@ import { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistan
 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";
 function looksLikeLeakedToolCallText(value) {
     const normalized = sanitizeVisibleText(value).trim();
     if (!normalized) {
@@ -24,6 +25,16 @@ function isLowSignalStructuredCompletion(value) {
     }
     return /Status:\s*completed[\s\S]*Summary:\s*-\s*none[\s\S]*Likely Causes:\s*-\s*none[\s\S]*Blockers:\s*-\s*none[\s\S]*Next Commands:\s*-\s*none/i.test(normalized);
 }
+function looksLikeToolBlocker(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (!normalized) {
+        return false;
+    }
+    return /^Blocked:\s*/iu.test(normalized)
+        || /error parsing tool call/iu.test(normalized)
+        || /invalid tool call/iu.test(normalized)
+        || /tool call.*schema/iu.test(normalized);
+}
 function normalizeToolOutputText(output) {
     const directText = typeof output === "string"
         ? sanitizeVisibleText(output).trim()
@@ -56,14 +67,35 @@ function extractLatestSuccessfulTaskResultText(executedToolResults) {
             continue;
         }
         const normalized = normalizeToolOutputText(toolResult.output);
-        if (normalized) {
+        if (normalized && !looksLikeToolBlocker(normalized)) {
             return normalized;
         }
     }
     return "";
 }
+function looksLikeReportOutput(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (!normalized) {
+        return false;
+    }
+    return /(?:^|\n)\s*Status\s*:/iu.test(normalized)
+        || /(?:^|\n)\s*Summary\s*:/iu.test(normalized)
+        || /(?:^|\n)\s*Likely Causes\s*:/iu.test(normalized)
+        || /(?:^|\n)\s*Blockers\s*:/iu.test(normalized)
+        || /(?:^|\n)\s*Next Commands\s*:/iu.test(normalized);
+}
+function looksLikeRawCommandTranscript(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (!normalized) {
+        return false;
+    }
+    return /^(?:stdout|stderr)\s*:/iu.test(normalized)
+        || /(?:^|\n)\s*(?:stdout|stderr)\s*:/iu.test(normalized)
+        || /(?:^|\n)\s*exitCode\s*:\s*-?\d+\s*$/iu.test(normalized);
+}
 function extractLatestSuccessfulNonTodoToolResultText(executedToolResults) {
-    for (const toolResult of [...executedToolResults].reverse()) {
+    const candidates = [];
+    for (const toolResult of executedToolResults) {
         if (toolResult.isError === true) {
             continue;
         }
@@ -72,32 +104,102 @@ function extractLatestSuccessfulNonTodoToolResultText(executedToolResults) {
         }
         const normalized = normalizeToolOutputText(toolResult.output);
         if (normalized) {
-            return normalized;
+            candidates.push(normalized);
         }
     }
-    return "";
+    return [...candidates].reverse().find(looksLikeReportOutput)
+        ?? [...candidates].reverse().find((candidate) => !looksLikeRawCommandTranscript(candidate))
+        ?? candidates.at(-1)
+        ?? "";
+}
+function hasDelegationBlocker(executedToolResults) {
+    return executedToolResults.some((toolResult) => {
+        if (toolResult.toolName !== "task") {
+            return false;
+        }
+        if (toolResult.isError === true) {
+            return true;
+        }
+        const normalized = normalizeToolOutputText(toolResult.output);
+        return looksLikeToolBlocker(normalized);
+    });
+}
+function looksLikeClarificationQuestion(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (!normalized) {
+        return false;
+    }
+    return /[?？]\s*$/u.test(normalized)
+        || /^(?:could you|can you|please provide|please share|i need|what is|which )/iu.test(normalized)
+        || /^(?:请问|请提供|能否提供|能不能提供)/u.test(normalized);
+}
+function looksLikeNonEvidenceApology(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (!normalized) {
+        return false;
+    }
+    return /(?:i(?:'|’)m sorry|sorry)[\s\S]*(?:couldn(?:'|’)t|cannot|can(?:'|’)t|unable to)\s+(?:complete|proceed|finish|continue)/iu.test(normalized)
+        || /(?:system limitation|technical limitation|internal limitation|recursion limit)/iu.test(normalized)
+        || /(?:抱歉|对不起)[\s\S]*(?:无法|不能|未能)(?:完成|继续|处理)/u.test(normalized);
+}
+function extractDeterministicToolFailureReport(executedToolResults) {
+    const hasSuccessfulSubstantiveTool = executedToolResults.some((toolResult) => (toolResult.isError !== true
+        && toolResult.toolName !== "write_todos"
+        && toolResult.toolName !== "read_todos"));
+    if (hasSuccessfulSubstantiveTool) {
+        return "";
+    }
+    const failures = executedToolResults.filter((toolResult) => toolResult.isError === true);
+    if (failures.length === 0) {
+        return "";
+    }
+    const blockerLines = failures
+        .slice(-3)
+        .map((toolResult) => `- ${renderToolFailure(toolResult.toolName, toolResult.output)}`);
+    return [
+        "Status: failed",
+        "Summary:",
+        "- The investigation could not proceed because required tools failed before any concrete evidence was gathered.",
+        "Likely Causes:",
+        "- none",
+        "Blockers:",
+        ...blockerLines,
+        "Next Commands:",
+        "- none",
+    ].join("\n");
 }
 export function resolveDeterministicFinalOutput(params) {
     const visibleOutput = params.visibleOutput ?? "";
     const toolFallback = params.toolFallback ?? "";
     const executedToolResults = params.executedToolResults ?? [];
-    const delegatedTaskOutput = extractLatestSuccessfulTaskResultText(executedToolResults);
-    if (delegatedTaskOutput) {
-        return delegatedTaskOutput;
-    }
     const sanitizedVisibleOutput = visibleOutput && !looksLikeLeakedToolCallText(visibleOutput)
         ? sanitizeVisibleText(visibleOutput).trim()
         : "";
+    const deterministicFailureReport = extractDeterministicToolFailureReport(executedToolResults);
+    const delegatedTaskOutput = extractLatestSuccessfulTaskResultText(executedToolResults);
+    const successfulToolOutput = extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
+    if (sanitizedVisibleOutput && successfulToolOutput && hasDelegationBlocker(executedToolResults)) {
+        return deterministicFailureReport || delegatedTaskOutput || successfulToolOutput;
+    }
+    if (sanitizedVisibleOutput
+        && (looksLikeClarificationQuestion(sanitizedVisibleOutput) || looksLikeNonEvidenceApology(sanitizedVisibleOutput))) {
+        return deterministicFailureReport || delegatedTaskOutput || successfulToolOutput || sanitizedVisibleOutput;
+    }
     if (sanitizedVisibleOutput && !isLowSignalStructuredCompletion(sanitizedVisibleOutput)) {
         return sanitizedVisibleOutput;
     }
-    const successfulToolOutput = extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
+    if (delegatedTaskOutput) {
+        return delegatedTaskOutput;
+    }
     if (successfulToolOutput) {
         return successfulToolOutput;
     }
     const sanitizedToolFallback = toolFallback && !looksLikeLeakedToolCallText(toolFallback)
         ? sanitizeVisibleText(toolFallback).trim()
         : "";
+    if (deterministicFailureReport) {
+        return deterministicFailureReport;
+    }
     return isLowSignalStructuredCompletion(sanitizedToolFallback) ? "" : sanitizedToolFallback;
 }
 export function extractDelegatedFindingsText(executedToolResults) {

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

@@ -4,7 +4,7 @@ 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 { appendToolRecoveryInstruction, extractVisibleOutput, resolveMissingPlanRecoveryInstruction, 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) {
@@ -40,6 +40,9 @@ function hasIncompleteExecutedPlan(executedToolResults) {
 function hasNonTodoToolEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.toolName !== "write_todos" && item.toolName !== "read_todos");
 }
+function hasPlanStateEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.toolName === "write_todos" || item.toolName === "read_todos" || readPlanStateSummary(item.output) !== null);
+}
 function extractLatestUserInput(request) {
     const typedRequest = request;
     const messages = Array.isArray(typedRequest.messages) ? typedRequest.messages : [];
@@ -80,7 +83,9 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             const hasExecutionBeyondTodoPlanning = hasNonTodoToolEvidence(executedToolResults);
             const recoveryInstruction = terminalText
                 ? resolveExecutionWithoutToolEvidenceTextInstruction(activeRequest, terminalText, false, {
+                    hasWriteTodosEvidence: executedToolResults.some((item) => item.toolName === "write_todos"),
                     hasToolResultEvidence: hasExecutionBeyondTodoPlanning,
+                    hasPlanStateEvidence: hasPlanStateEvidence(executedToolResults),
                     hasIncompletePlanState: hasExecutionBeyondTodoPlanning && hasIncompletePlanState,
                 })
                 : hasIncompletePlanState && hasExecutionBeyondTodoPlanning
@@ -95,6 +100,21 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             }
             break;
         }
+        const missingPlanRecoveryInstruction = resolveMissingPlanRecoveryInstruction({
+            request: activeRequest,
+            hasPlanStateEvidence: hasPlanStateEvidence(executedToolResults),
+            hasWriteTodosEvidence: executedToolResults.some((item) => item.toolName === "write_todos"),
+            hasToolResultEvidence: executedToolResults.length > 0 || toolCalls.length > 0,
+        });
+        if (missingPlanRecoveryInstruction
+            && toolCalls.some((toolCall) => {
+                const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
+                return resolvedToolName !== "write_todos" && resolvedToolName !== "read_todos" && toolCall.name !== "write_todos" && toolCall.name !== "read_todos";
+            })) {
+            activeRequest = appendToolRecoveryInstruction(activeRequest, missingPlanRecoveryInstruction);
+            pendingResult = undefined;
+            continue;
+        }
         if (!canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools)) {
             break;
         }

package/dist/runtime/adapter/middleware/context-hygiene.d.ts

@@ -0,0 +1,5 @@
+export declare function pruneReasoningMetadataFromMessages(messages: unknown): {
+    messages: unknown;
+    changed: boolean;
+};
+export declare function createContextHygieneMiddleware(): unknown;

package/dist/runtime/adapter/middleware/context-hygiene.js

@@ -0,0 +1,83 @@
+import { createMiddleware } from "langchain";
+import { isRecord } from "../../../utils/object.js";
+const REASONING_METADATA_KEYS = new Set([
+    "reasoning",
+    "reasoning_content",
+    "thinking",
+    "redacted_thinking",
+]);
+const REASONING_CONTENT_BLOCK_TYPES = new Set([
+    "reasoning",
+    "thinking",
+    "redacted_thinking",
+]);
+function pruneReasoningValue(value) {
+    if (Array.isArray(value)) {
+        let changed = false;
+        const next = [];
+        for (const item of value) {
+            if (isRecord(item) && typeof item.type === "string" && REASONING_CONTENT_BLOCK_TYPES.has(item.type)) {
+                changed = true;
+                continue;
+            }
+            const pruned = pruneReasoningValue(item);
+            changed = changed || pruned.changed;
+            next.push(pruned.value);
+        }
+        return changed ? { value: next, changed } : { value, changed: false };
+    }
+    if (!isRecord(value)) {
+        return { value, changed: false };
+    }
+    let changed = false;
+    const next = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (REASONING_METADATA_KEYS.has(key)) {
+            changed = true;
+            continue;
+        }
+        const pruned = pruneReasoningValue(entry);
+        changed = changed || pruned.changed;
+        next[key] = pruned.value;
+    }
+    return changed ? { value: next, changed } : { value, changed: false };
+}
+function pruneMessageReasoningMetadata(message) {
+    if (!isRecord(message)) {
+        return { message, changed: false };
+    }
+    let changed = false;
+    const next = Object.assign(Object.create(Object.getPrototypeOf(message)), message);
+    for (const key of ["additional_kwargs", "response_metadata", "content", "lc_kwargs", "kwargs"]) {
+        const pruned = pruneReasoningValue(message[key]);
+        if (pruned.changed) {
+            next[key] = pruned.value;
+            changed = true;
+        }
+    }
+    return changed ? { message: next, changed } : { message, changed: false };
+}
+export function pruneReasoningMetadataFromMessages(messages) {
+    if (!Array.isArray(messages)) {
+        return { messages, changed: false };
+    }
+    let changed = false;
+    const next = messages.map((message) => {
+        const pruned = pruneMessageReasoningMetadata(message);
+        changed = changed || pruned.changed;
+        return pruned.message;
+    });
+    return changed ? { messages: next, changed } : { messages, changed: false };
+}
+export function createContextHygieneMiddleware() {
+    return createMiddleware({
+        name: "HarnessContextHygieneMiddleware",
+        beforeModel: (state) => {
+            if (!isRecord(state)) {
+                return undefined;
+            }
+            const pruned = pruneReasoningMetadataFromMessages(state.messages);
+            return pruned.changed ? { messages: pruned.messages } : undefined;
+        },
+    });
+}

package/dist/runtime/adapter/middleware-assembly.d.ts

@@ -1,6 +1,9 @@
 import { FilesystemBackend } from "deepagents";
 import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, DeepAgentParams, RuntimeAdapterOptions } from "../../contracts/types.js";
 import type { ExecutableTool } from "./flow/invoke-runtime.js";
+type RunnableLike = {
+    invoke: (input: unknown, config?: Record<string, unknown>) => Promise<unknown>;
+};
 export type LangChainRuntimeExtensionPlan = {
     includePatchToolCalls: boolean;
     includeAutomaticSummarization: boolean;
@@ -27,7 +30,13 @@ export type UpstreamSubagentConfig = {
     }>;
     responseFormat?: unknown;
     middleware?: unknown[];
+    runnable?: RunnableLike;
 };
+export declare function extractSubagentRequestText(state: unknown): string;
+export declare function wrapRequestResultAsSubagentResponse(result: {
+    output: string;
+    structuredResponse?: unknown;
+}): Record<string, unknown>;
 export declare function buildBuiltinTaskSubagentMiddleware(input: {
     selectedSubagent: UpstreamSubagentConfig;
     builtinBackend: unknown;
@@ -49,6 +58,7 @@ export declare function resolveSubagents(input: {
     resolveModel: (model: CompiledModel) => Promise<unknown>;
     resolveTools: (tools: Parameters<DeepAgentParams["tools"]["slice"]>[0] extends never ? never : any, binding?: CompiledAgentBinding) => unknown[];
     createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
+    resolveBackend?: (binding?: CompiledAgentBinding) => unknown;
 }): Promise<UpstreamSubagentConfig[]>;
 export declare function invokeBuiltinTaskTool(input: {
     binding: CompiledAgentBinding;
@@ -118,3 +128,4 @@ export declare function resolveMiddleware(input: {
     createDeclaredMiddlewareResolverOptions: (binding?: CompiledAgentBinding) => unknown;
     resolveLangChainRuntimeExtensionMiddleware: (binding: CompiledAgentBinding) => Promise<unknown[]>;
 }): Promise<unknown[]>;
+export {};