@botbotgo/agent-harness 0.0.326 → 0.0.328

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

@@ -1,6 +1,7 @@
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from "../../agent-runtime-adapter.js";
+import { ExecutionReconciliationError } from "../../adapter/flow/stream-runtime.js";
 import { buildRequestPlanState, summarizeBuiltinWriteTodosArgs } from "../../adapter/runtime-adapter-support.js";
-import { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
+import { describeRuntimeError, renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
 import { createContentBlocksItem, createToolResultKey, } from "../events/streaming.js";
 import { projectRuntimeSurfaceFromSingleUpstreamEvent } from "./inspection.js";
@@ -19,10 +20,64 @@ function createInitialPlanState(sessionId, requestId, updatedAt) {
             completed: 0,
             failed: 0,
             cancelled: 0,
-            blocked: 0,
         },
     };
 }
+function planStateHasUnfinishedItems(planState) {
+    if (!planState) {
+        return false;
+    }
+    return planState.summary.pending > 0 || planState.summary.inProgress > 0;
+}
+function planStateHasActiveItems(planState) {
+    if (!planState) {
+        return false;
+    }
+    return planState.summary.pending > 0 || planState.summary.inProgress > 0;
+}
+function readTerminalStructuredStatus(value) {
+    if (typeof value === "string") {
+        try {
+            return readTerminalStructuredStatus(JSON.parse(value));
+        }
+        catch {
+            return null;
+        }
+    }
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const typed = value;
+    if (typed.status === "completed") {
+        return typed.status;
+    }
+    return (readTerminalStructuredStatus(typed.structuredResponse)
+        ?? readTerminalStructuredStatus(typed.output)
+        ?? readTerminalStructuredStatus(typed.data));
+}
+function reconcilePlanStateToTerminalStatus(planState, status, updatedAt) {
+    const items = planState.items.map((item) => ({
+        ...item,
+        status: item.status === "pending" || item.status === "in_progress"
+            ? status
+            : item.status,
+    }));
+    const summary = {
+        total: items.length,
+        pending: 0,
+        inProgress: 0,
+        completed: items.filter((item) => item.status === "completed").length,
+        failed: items.filter((item) => item.status === "failed").length,
+        cancelled: items.filter((item) => item.status === "cancelled").length,
+    };
+    return {
+        ...planState,
+        version: planState.version + 1,
+        updatedAt,
+        items,
+        summary,
+    };
+}
 function getPlanStateFromToolResult(input) {
     if (typeof input.output !== "object" || input.output === null) {
         return null;
@@ -80,6 +135,26 @@ function buildPlanStateSignature(planState) {
 function countStructuredTodoIds(items) {
     return items.filter((item) => typeof item.id === "string" && item.id.length > 0).length;
 }
+async function emitPlanStateUpdate(options, agentId, planState) {
+    await options.saveRequestPlanState?.(options.sessionId, options.requestId, planState);
+    return [{
+            type: "plan-state",
+            sessionId: options.sessionId,
+            requestId: options.requestId,
+            agentId,
+            planState,
+        }];
+}
+async function refreshPlanStateFromPersistence(options, currentPlanState) {
+    const persistedPlanState = await options.loadRequestPlanState?.(options.sessionId, options.requestId);
+    if (!persistedPlanState) {
+        return currentPlanState;
+    }
+    if (!currentPlanState || persistedPlanState.version >= currentPlanState.version) {
+        return persistedPlanState;
+    }
+    return currentPlanState;
+}
 function shouldEmitPlanState(currentPlanState, nextPlanState) {
     if (!currentPlanState || currentPlanState.items.length === 0) {
         return true;
@@ -210,7 +285,6 @@ function summarizePlanState(planState) {
         planState.summary.inProgress > 0 ? `${planState.summary.inProgress} in progress` : "",
         planState.summary.pending > 0 ? `${planState.summary.pending} pending` : "",
         planState.summary.completed > 0 ? `${planState.summary.completed} completed` : "",
-        planState.summary.blocked > 0 ? `${planState.summary.blocked} blocked` : "",
         planState.summary.failed > 0 ? `${planState.summary.failed} failed` : "",
     ].filter((value) => value.length > 0);
     if (counts.length === 0) {
@@ -228,6 +302,9 @@ function createSurfaceCommentary(surfaceItem) {
             return `Running tool ${name}.`;
         }
         if (surfaceItem.status === "completed") {
+            if (name.toLowerCase() === "task") {
+                return null;
+            }
             return `Tool ${name} completed.`;
         }
         if (surfaceItem.status === "failed") {
@@ -252,7 +329,7 @@ function createSurfaceCommentary(surfaceItem) {
             return `Delegating work to ${name}.`;
         }
         if (surfaceItem.status === "completed") {
-            return `Delegation to ${name} completed.`;
+            return null;
         }
         if (surfaceItem.status === "failed") {
             return `Delegation to ${name} failed.`;
@@ -360,6 +437,7 @@ export async function* streamHarnessRun(options) {
     let streamActivityObserved = false;
     let nonUpstreamStreamActivityObserved = false;
     let assistantOutput = "";
+    let assistantOutputCameFromInvokeFallback = false;
     const bufferAssistantTextUntilCompletion = true;
     let currentAgentId = options.selectedAgentId;
     let currentAgentName = formatAgentName(options.selectedAgentId);
@@ -425,19 +503,32 @@ export async function* streamHarnessRun(options) {
                         planStateVersion = upstreamPlanState.version;
                         lastPlanStateSignature = signature;
                         currentPlanState = upstreamPlanState;
-                        yield {
-                            type: "plan-state",
-                            sessionId: options.sessionId,
-                            requestId: options.requestId,
-                            agentId: currentAgentId,
-                            planState: upstreamPlanState,
-                        };
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, upstreamPlanState)) {
+                            yield item;
+                        }
                         const commentary = summarizePlanState(upstreamPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
                     }
                 }
+                const terminalStructuredStatus = readTerminalStructuredStatus(normalizedChunk.event);
+                if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
+                    const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                    const signature = buildPlanStateSignature(reconciledPlanState);
+                    if (signature !== lastPlanStateSignature) {
+                        planStateVersion = reconciledPlanState.version;
+                        lastPlanStateSignature = signature;
+                        currentPlanState = reconciledPlanState;
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                            yield item;
+                        }
+                        const commentary = summarizePlanState(reconciledPlanState);
+                        if (commentary) {
+                            yield* emitCommentary(commentary);
+                        }
+                    }
+                }
                 upstreamEventOrdinal += 1;
                 const projectionBinding = options.getBinding(currentAgentId) ?? options.binding;
                 const surfaceProjection = projectRuntimeSurfaceFromSingleUpstreamEvent({
@@ -553,7 +644,7 @@ export async function* streamHarnessRun(options) {
                     type: "tool-result",
                     sessionId: options.sessionId,
                     requestId: options.requestId,
-                    agentId: options.selectedAgentId,
+                    agentId: currentAgentId,
                     toolName: normalizedChunk.toolName,
                     output: normalizedChunk.output,
                     isError: normalizedChunk.isError,
@@ -578,19 +669,32 @@ export async function* streamHarnessRun(options) {
                     if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, planState)) {
                         lastPlanStateSignature = signature;
                         currentPlanState = planState;
-                        yield {
-                            type: "plan-state",
-                            sessionId: options.sessionId,
-                            requestId: options.requestId,
-                            agentId: currentAgentId,
-                            planState,
-                        };
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, planState)) {
+                            yield item;
+                        }
                         const commentary = summarizePlanState(planState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
                     }
                 }
+                const terminalStructuredStatus = readTerminalStructuredStatus(normalizedChunk.output);
+                if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
+                    const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                    const signature = buildPlanStateSignature(reconciledPlanState);
+                    if (signature !== lastPlanStateSignature) {
+                        planStateVersion = reconciledPlanState.version;
+                        lastPlanStateSignature = signature;
+                        currentPlanState = reconciledPlanState;
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                            yield item;
+                        }
+                        const commentary = summarizePlanState(reconciledPlanState);
+                        if (commentary) {
+                            yield* emitCommentary(commentary);
+                        }
+                    }
+                }
                 continue;
             }
             emitted = true;
@@ -614,6 +718,7 @@ export async function* streamHarnessRun(options) {
             assistantOutput = toolErrors.join("\n\n");
             emitted = true;
         }
+        currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
         if (!assistantOutput) {
             const actual = await options.invokeWithHistory(options.binding, options.input, options.sessionId, options.requestId);
             if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
@@ -622,6 +727,7 @@ export async function* streamHarnessRun(options) {
             if (actual.output) {
                 assistantOutput = actual.output;
                 emitted = true;
+                assistantOutputCameFromInvokeFallback = true;
             }
             const finalPlanState = getLatestPlanStateFromExecutedToolResults({
                 sessionId: options.sessionId,
@@ -636,19 +742,42 @@ export async function* streamHarnessRun(options) {
                     planStateVersion = finalPlanState.version;
                     lastPlanStateSignature = signature;
                     currentPlanState = finalPlanState;
-                    yield {
-                        type: "plan-state",
-                        sessionId: options.sessionId,
-                        requestId: options.requestId,
-                        agentId: currentAgentId,
-                        planState: finalPlanState,
-                    };
+                    for (const item of await emitPlanStateUpdate(options, currentAgentId, finalPlanState)) {
+                        yield item;
+                    }
                     const commentary = summarizePlanState(finalPlanState);
                     if (commentary) {
                         yield* emitCommentary(commentary);
                     }
                 }
             }
+            currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
+            const terminalStructuredStatus = readTerminalStructuredStatus(actual.structuredResponse);
+            if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
+                const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                const signature = buildPlanStateSignature(reconciledPlanState);
+                if (signature !== lastPlanStateSignature) {
+                    planStateVersion = reconciledPlanState.version;
+                    lastPlanStateSignature = signature;
+                    currentPlanState = reconciledPlanState;
+                    for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                        yield item;
+                    }
+                    const commentary = summarizePlanState(reconciledPlanState);
+                    if (commentary) {
+                        yield* emitCommentary(commentary);
+                    }
+                }
+            }
+        }
+        currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
+        if (assistantOutputCameFromInvokeFallback
+            && nonUpstreamStreamActivityObserved
+            && planStateHasActiveItems(currentPlanState)) {
+            throw new ExecutionReconciliationError("Agent ended while the streamed plan state still had unfinished work.");
+        }
+        if (planStateHasActiveItems(currentPlanState)) {
+            throw new ExecutionReconciliationError("Agent ended while the streamed plan state still had unfinished work.");
         }
         if (assistantOutput && bufferAssistantTextUntilCompletion) {
             yield {
@@ -686,13 +815,15 @@ export async function* streamHarnessRun(options) {
     catch (error) {
         const shouldRetryAfterStreamingCompatibilityError = !assistantOutput &&
             isOpenAICompatibleStreamingCompatibilityError(options.binding, error);
-        if ((emitted || streamActivityObserved) && !shouldRetryAfterStreamingCompatibilityError) {
+        if ((emitted || streamActivityObserved)
+            && !shouldRetryAfterStreamingCompatibilityError) {
             const runtimeFailure = renderRuntimeFailure(error);
+            const detailedError = describeRuntimeError(error);
             yield {
                 type: "event",
                 event: await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "failed", {
                     previousState: "running",
-                    error: error instanceof Error ? error.message : String(error),
+                    error: detailedError,
                 }),
             };
             yield {
@@ -717,11 +848,12 @@ export async function* streamHarnessRun(options) {
         }
         if (error instanceof RuntimeOperationTimeoutError && error.stage === "invoke") {
             const runtimeFailure = renderRuntimeFailure(error);
+            const detailedError = describeRuntimeError(error);
             yield {
                 type: "event",
                 event: await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "failed", {
                     previousState: "running",
-                    error: error.message,
+                    error: detailedError,
                 }),
             };
             yield {
@@ -744,6 +876,36 @@ export async function* streamHarnessRun(options) {
             };
             return;
         }
+        if (error instanceof ExecutionReconciliationError) {
+            const runtimeFailure = renderRuntimeFailure(error);
+            const detailedError = describeRuntimeError(error);
+            yield {
+                type: "event",
+                event: await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "failed", {
+                    previousState: "running",
+                    error: detailedError,
+                }),
+            };
+            yield {
+                type: "content",
+                sessionId: options.sessionId,
+                requestId: options.requestId,
+                agentId: options.selectedAgentId,
+                content: runtimeFailure,
+            };
+            yield {
+                type: "result",
+                result: {
+                    sessionId: options.sessionId,
+                    requestId: options.requestId,
+                    agentId: currentAgentId,
+                    state: "failed",
+                    output: runtimeFailure,
+                    finalMessageText: runtimeFailure,
+                },
+            };
+            return;
+        }
         try {
             syntheticFallback = {
                 strategy: "stream-to-invoke",
@@ -757,6 +919,19 @@ export async function* streamHarnessRun(options) {
             if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
                 yield createContentBlocksItem(options.sessionId, options.requestId, options.selectedAgentId, actual.contentBlocks);
             }
+            if (actual.output) {
+                yield {
+                    type: "event",
+                    event: await options.emit(options.sessionId, options.requestId, 3, "output.delta", { content: actual.output }),
+                };
+                yield {
+                    type: "content",
+                    sessionId: options.sessionId,
+                    requestId: options.requestId,
+                    agentId: currentAgentId,
+                    content: actual.output,
+                };
+            }
             const terminalEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, actual.state, {
                 previousState: "running",
             });
@@ -798,11 +973,12 @@ export async function* streamHarnessRun(options) {
             };
             await options.emitSyntheticFallback(options.sessionId, options.requestId, options.selectedAgentId, syntheticFallback);
             const runtimeFailure = renderRuntimeFailure(invokeError);
+            const detailedError = describeRuntimeError(invokeError);
             yield {
                 type: "event",
                 event: await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "failed", {
                     previousState: "running",
-                    error: invokeError instanceof Error ? invokeError.message : String(invokeError),
+                    error: detailedError,
                 }),
             };
             yield {

package/dist/runtime/harness.js

@@ -215,6 +215,7 @@ export class AgentHarnessRuntime {
             runtimeAdapterOptions: {
                 ...runtimeAdapterOptions,
                 scheduleManager: runtimeAdapterOptions.scheduleManager ?? this.scheduleManager,
+                bindingResolver: runtimeAdapterOptions.bindingResolver ?? ((agentId) => this.workspace.bindings.get(agentId)),
                 functionToolContextResolver: runtimeAdapterOptions.functionToolContextResolver ?? ((input) => this.buildFunctionToolContext(input)),
             },
             checkpointers: this.checkpointers,
@@ -1303,6 +1304,8 @@ export class AgentHarnessRuntime {
             clearRequestInput: (sessionId, requestId) => this.persistence.clearRequestInput(sessionId, requestId),
             updateRequestInspection: (sessionId, requestId, patch) => this.persistence.updateRequestInspection(sessionId, requestId, patch),
             appendRequestTraceItem: (sessionId, requestId, item) => this.persistence.appendRequestTraceItem(sessionId, requestId, item),
+            loadRequestPlanState: (sessionId, requestId) => this.persistence.getRequestPlanState(sessionId, requestId),
+            saveRequestPlanState: (sessionId, requestId, planState) => this.persistence.saveRequestPlanState(sessionId, requestId, planState),
             emitSyntheticFallback: (sessionId, requestId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(sessionId, requestId, selectedAgentId, error),
         });
         for await (const item of stream) {

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

@@ -1,5 +1,5 @@
 import { AIMessage } from "langchain";
-import { salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
+import { salvageFunctionLikeToolCall, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
 export function sanitizeVisibleText(value) {
     return value
         .replace(/[A-Za-z0-9_]*Middleware\.after_model/g, "")
@@ -403,19 +403,26 @@ function normalizeAgentMessage(value) {
         })
             .filter((toolCall) => toolCall !== null)
         : [];
-    const recoveredToolCalls = normalizedInvalidToolCalls.filter((toolCall) => typeof toolCall.args === "object" && !!toolCall.args && !Array.isArray(toolCall.args));
     const normalizedContent = typeof typed.content === "string" || Array.isArray(typed.content)
         ? typed.content
         : typeof typed.content === "object" && typed.content
             ? readTextContent(typed.content)
             : "";
+    const recoveredToolCalls = normalizedInvalidToolCalls.filter((toolCall) => typeof toolCall.args === "object" && !!toolCall.args && !Array.isArray(toolCall.args));
+    const functionLikeToolCall = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && typeof normalizedContent === "string"
+        ? salvageFunctionLikeToolCall(normalizedContent)
+        : null;
     return new AIMessage({
-        content: normalizedContent,
+        content: functionLikeToolCall ? "" : normalizedContent,
         name: typeof typed.name === "string" ? typed.name : undefined,
         additional_kwargs: typeof typed.additional_kwargs === "object" && typed.additional_kwargs ? typed.additional_kwargs : {},
         response_metadata: typeof typed.response_metadata === "object" && typed.response_metadata ? typed.response_metadata : {},
         id: typeof typed.id === "string" ? typed.id : undefined,
-        tool_calls: [...normalizedToolCalls, ...recoveredToolCalls],
+        tool_calls: [
+            ...normalizedToolCalls,
+            ...recoveredToolCalls,
+            ...(functionLikeToolCall ? [{ name: functionLikeToolCall.name, args: functionLikeToolCall.args }] : []),
+        ],
         invalid_tool_calls: normalizedInvalidToolCalls.filter((toolCall) => toolCall.type !== "tool_call"),
         usage_metadata: typeof typed.usage_metadata === "object" && typed.usage_metadata ? typed.usage_metadata : undefined,
     });

package/dist/runtime/parsing/output-recovery.d.ts

@@ -11,6 +11,9 @@ export declare function resolveExecutionWithoutToolEvidenceInstruction(request:
 export declare function resolveExecutionWithoutToolEvidenceTextInstruction(request: unknown, assistantText: string, toolCallEvidence?: boolean, resultEvidence?: {
     hasWriteTodosEvidence?: boolean;
     hasToolResultEvidence?: boolean;
+    hasIncompletePlanState?: boolean;
+    hasOpenTaskDelegation?: boolean;
+    hasMissingDelegatedExecutionEvidence?: boolean;
 }): string | null;
 export declare function resolveToolCallRecoveryInstruction(error: unknown): string | null;
 export declare function appendToolRecoveryInstruction(input: unknown, instruction: string): unknown;

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

@@ -1,5 +1,38 @@
-import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, } from "../prompts/runtime-prompts.js";
+import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 import { wrapNormalizedMessage, readTextContent } from "./output-content.js";
+function collectRequestMessages(request) {
+    if (typeof request !== "object" || !request || Array.isArray(request)) {
+        return [];
+    }
+    const typed = request;
+    return Array.isArray(typed.messages)
+        ? typed.messages.filter((message) => typeof message === "object" && !!message && !Array.isArray(message))
+        : [];
+}
+function readMessageRole(message) {
+    return typeof message.role === "string" ? message.role.trim().toLowerCase() : "";
+}
+function readLatestUserRequestText(request) {
+    const messages = collectRequestMessages(request);
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (readMessageRole(message) !== "user") {
+            continue;
+        }
+        const content = readTextContent(message.content).trim();
+        if (content) {
+            return content;
+        }
+    }
+    return "";
+}
+function readSystemInstructionText(request) {
+    return collectRequestMessages(request)
+        .filter((message) => readMessageRole(message) === "system")
+        .map((message) => readTextContent(message.content).trim())
+        .filter(Boolean)
+        .join("\n\n");
+}
 function isToolCallParseFailure(error) {
     return error instanceof Error && /error parsing tool call:/i.test(error.message);
 }
@@ -72,20 +105,33 @@ export function isRetrySafeInvalidToolSelectionError(value) {
     return !!text && /is not a valid tool, try one of \[/i.test(text);
 }
 export function shouldValidateExecutionWithoutToolEvidence(request) {
-    void request;
-    return false;
+    const userText = readLatestUserRequestText(request);
+    if (userText) {
+        return true;
+    }
+    return readSystemInstructionText(request).length > 0;
 }
 export function resolveExecutionWithoutToolEvidenceInstruction(request, result) {
-    void request;
-    void result;
-    return null;
+    const assistantText = readTextContent(result).trim();
+    return resolveExecutionWithoutToolEvidenceTextInstruction(request, assistantText, false, {});
 }
 export function resolveExecutionWithoutToolEvidenceTextInstruction(request, assistantText, toolCallEvidence = false, resultEvidence = {}) {
-    void request;
-    void assistantText;
-    void toolCallEvidence;
-    void resultEvidence;
-    return null;
+    if (!shouldValidateExecutionWithoutToolEvidence(request)) {
+        return null;
+    }
+    const normalizedText = assistantText.trim();
+    const hasUnfinishedExecution = resultEvidence.hasIncompletePlanState === true
+        || resultEvidence.hasOpenTaskDelegation === true
+        || resultEvidence.hasMissingDelegatedExecutionEvidence === true;
+    if (!normalizedText || !hasUnfinishedExecution) {
+        return null;
+    }
+    const hasExecutionEvidence = toolCallEvidence
+        || resultEvidence.hasWriteTodosEvidence === true
+        || resultEvidence.hasToolResultEvidence === true;
+    return hasExecutionEvidence
+        ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
+        : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;
 }
 export function resolveToolCallRecoveryInstruction(error) {
     if (isRepairableWriteTodosEmptyFailure(error))

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

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