@botbotgo/agent-harness 0.0.340 → 0.0.342

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

@@ -43,7 +43,7 @@ function readTerminalStructuredStatus(value) {
             return readTerminalStructuredStatus(JSON.parse(value));
         }
         catch {
-            return null;
+            return /^\s*Status:\s*completed\b/im.test(value) ? "completed" : null;
         }
     }
     if (typeof value !== "object" || value === null) {
@@ -54,9 +54,20 @@ function readTerminalStructuredStatus(value) {
         return typed.status;
     }
     return (readTerminalStructuredStatus(typed.structuredResponse)
+        ?? readTerminalStructuredStatus(typed.content)
         ?? readTerminalStructuredStatus(typed.output)
         ?? readTerminalStructuredStatus(typed.data));
 }
+function isSubstantiveTerminalAssistantOutput(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (normalized.length < 80) {
+        return false;
+    }
+    if (/\b(?:delegated|waiting|wait for|initiated)\b/i.test(normalized) && !/\b(?:finding|summary|root cause|evidence|completed|result|issue)\b/i.test(normalized)) {
+        return false;
+    }
+    return true;
+}
 function reconcilePlanStateToTerminalStatus(planState, status, updatedAt) {
     const items = planState.items.map((item) => ({
         ...item,
@@ -134,6 +145,57 @@ function buildPlanStateSignature(planState) {
         summary: planState.summary,
     });
 }
+function recomputePlanSummary(items) {
+    return {
+        total: items.length,
+        pending: items.filter((item) => item.status === "pending").length,
+        inProgress: items.filter((item) => item.status === "in_progress").length,
+        completed: items.filter((item) => item.status === "completed").length,
+        failed: items.filter((item) => item.status === "failed").length,
+        cancelled: items.filter((item) => item.status === "cancelled").length,
+    };
+}
+function normalizePlanItemKey(item) {
+    return typeof item.id === "string" && item.id.trim().length > 0
+        ? `id:${item.id.trim()}`
+        : `content:${item.content.trim().toLowerCase()}`;
+}
+function mergePartialPlanState(currentPlanState, incomingPlanState) {
+    if (!currentPlanState || incomingPlanState.items.length >= currentPlanState.items.length) {
+        return incomingPlanState;
+    }
+    const currentByKey = new Map(currentPlanState.items.map((item, index) => [normalizePlanItemKey(item), { item, index }]));
+    const incomingByKey = new Map();
+    for (const incomingItem of incomingPlanState.items) {
+        const key = normalizePlanItemKey(incomingItem);
+        if (!currentByKey.has(key)) {
+            const currentStructuredIds = countStructuredTodoIds(currentPlanState.items);
+            const incomingStructuredIds = countStructuredTodoIds(incomingPlanState.items);
+            if (currentStructuredIds > 0 && incomingStructuredIds === 0) {
+                return currentPlanState;
+            }
+            const mergedItems = currentPlanState.items.map((item, index) => {
+                const incomingByIndex = incomingPlanState.items[index];
+                return incomingByIndex ? { ...item, status: incomingByIndex.status } : item;
+            });
+            return {
+                ...incomingPlanState,
+                items: mergedItems,
+                summary: recomputePlanSummary(mergedItems),
+            };
+        }
+        incomingByKey.set(key, incomingItem);
+    }
+    const mergedItems = currentPlanState.items.map((item) => {
+        const incomingItem = incomingByKey.get(normalizePlanItemKey(item));
+        return incomingItem ? { ...item, ...incomingItem } : item;
+    });
+    return {
+        ...incomingPlanState,
+        items: mergedItems,
+        summary: recomputePlanSummary(mergedItems),
+    };
+}
 function countStructuredTodoIds(items) {
     return items.filter((item) => typeof item.id === "string" && item.id.length > 0).length;
 }
@@ -283,16 +345,49 @@ function summarizePlanState(planState) {
     if (planState.summary.total <= 0) {
         return null;
     }
-    const counts = [
-        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.failed > 0 ? `${planState.summary.failed} failed` : "",
-    ].filter((value) => value.length > 0);
-    if (counts.length === 0) {
-        counts.push(`${planState.summary.total} total`);
-    }
-    return `Plan updated: ${counts.join(", ")}.`;
+    const statusMarker = (status) => {
+        switch (status) {
+            case "completed":
+                return "[x]";
+            case "in_progress":
+                return "[~]";
+            case "failed":
+                return "[!]";
+            case "cancelled":
+                return "[-]";
+            default:
+                return "[ ]";
+        }
+    };
+    const items = planState.items.slice(0, 6).map((item) => `${statusMarker(item.status)} ${item.content}`);
+    const suffix = planState.items.length > items.length ? ` | +${planState.items.length - items.length} more` : "";
+    return `TODO: ${items.join(" | ")}${suffix}`;
+}
+function summarizePlanStateTerminalTransitions(previousPlanState, nextPlanState) {
+    const previousByKey = new Map((previousPlanState?.items ?? []).map((item) => [normalizePlanItemKey(item), item]));
+    const terminalLabel = (status) => {
+        switch (status) {
+            case "completed":
+                return "completed";
+            case "failed":
+                return "failed";
+            case "cancelled":
+                return "cancelled";
+            default:
+                return null;
+        }
+    };
+    return nextPlanState.items.flatMap((item) => {
+        const label = terminalLabel(item.status);
+        if (!label) {
+            return [];
+        }
+        const previousStatus = previousByKey.get(normalizePlanItemKey(item))?.status;
+        if (previousStatus === item.status) {
+            return [];
+        }
+        return [`TODO ${label}: ${item.content}.`];
+    });
 }
 function createSurfaceCommentary(surfaceItem) {
     const name = normalizeCommentaryText(surfaceItem.name);
@@ -446,6 +541,10 @@ export async function* streamHarnessRun(options) {
     let delegationChain = [options.selectedAgentId];
     let upstreamEventOrdinal = 0;
     let syntheticFallback;
+    const toolErrors = [];
+    let sawSuccessfulToolResult = false;
+    let lastToolResultKey = null;
+    const executedToolResults = [];
     const emittedCommentary = new Set();
     const emitCommentary = function* (content) {
         const normalized = normalizeCommentaryText(content);
@@ -467,10 +566,6 @@ export async function* streamHarnessRun(options) {
             options.releaseRequestSlotPromise,
         ]).then(([loadedPriorHistory, resolvedReleaseRunSlot]) => [loadedPriorHistory, resolvedReleaseRunSlot]);
         releaseRunSlot = acquiredReleaseRunSlot;
-        const toolErrors = [];
-        let sawSuccessfulToolResult = false;
-        let lastToolResultKey = null;
-        const executedToolResults = [];
         const recalledMemories = options.invocation.memoryRecall?.items ?? [];
         for (const item of createRuntimeMemoryRecallSteps(options.sessionId, options.requestId, recalledMemories)) {
             yield item;
@@ -502,32 +597,20 @@ export async function* streamHarnessRun(options) {
                     updatedAt: new Date().toISOString(),
                 });
                 if (upstreamPlanState) {
-                    const signature = buildPlanStateSignature(upstreamPlanState);
-                    if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, upstreamPlanState)) {
-                        planStateVersion = upstreamPlanState.version;
+                    const mergedPlanState = mergePartialPlanState(currentPlanState, upstreamPlanState);
+                    const signature = buildPlanStateSignature(mergedPlanState);
+                    if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, mergedPlanState)) {
+                        const previousPlanState = currentPlanState;
+                        planStateVersion = mergedPlanState.version;
                         lastPlanStateSignature = signature;
-                        currentPlanState = upstreamPlanState;
-                        for (const item of await emitPlanStateUpdate(options, currentAgentId, upstreamPlanState)) {
+                        currentPlanState = mergedPlanState;
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
                             yield item;
                         }
-                        const commentary = summarizePlanState(upstreamPlanState);
-                        if (commentary) {
+                        for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, mergedPlanState)) {
                             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);
+                        const commentary = summarizePlanState(mergedPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
@@ -677,30 +760,41 @@ export async function* streamHarnessRun(options) {
                         updatedAt: new Date().toISOString(),
                     });
                 if (planState) {
-                    const signature = buildPlanStateSignature(planState);
-                    if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, planState)) {
+                    const mergedPlanState = mergePartialPlanState(currentPlanState, planState);
+                    const signature = buildPlanStateSignature(mergedPlanState);
+                    if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, mergedPlanState)) {
+                        const previousPlanState = currentPlanState;
                         lastPlanStateSignature = signature;
-                        currentPlanState = planState;
-                        for (const item of await emitPlanStateUpdate(options, currentAgentId, planState)) {
+                        currentPlanState = mergedPlanState;
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
                             yield item;
                         }
-                        const commentary = summarizePlanState(planState);
+                        for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, mergedPlanState)) {
+                            yield* emitCommentary(commentary);
+                        }
+                        const commentary = summarizePlanState(mergedPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
                     }
                 }
-                const terminalStructuredStatus = readTerminalStructuredStatus(normalizedChunk.output);
+                const terminalStructuredStatus = normalizedChunk.toolName === "task"
+                    ? readTerminalStructuredStatus(normalizedChunk.output)
+                    : null;
                 if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
                     const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
                     const signature = buildPlanStateSignature(reconciledPlanState);
                     if (signature !== lastPlanStateSignature) {
+                        const previousPlanState = currentPlanState;
                         planStateVersion = reconciledPlanState.version;
                         lastPlanStateSignature = signature;
                         currentPlanState = reconciledPlanState;
                         for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
                             yield item;
                         }
+                        for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, reconciledPlanState)) {
+                            yield* emitCommentary(commentary);
+                        }
                         const commentary = summarizePlanState(reconciledPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
@@ -757,15 +851,20 @@ export async function* streamHarnessRun(options) {
                 updatedAt: new Date().toISOString(),
             });
             if (finalPlanState) {
-                const signature = buildPlanStateSignature(finalPlanState);
-                if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, finalPlanState)) {
-                    planStateVersion = finalPlanState.version;
+                const mergedPlanState = mergePartialPlanState(currentPlanState, finalPlanState);
+                const signature = buildPlanStateSignature(mergedPlanState);
+                if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, mergedPlanState)) {
+                    const previousPlanState = currentPlanState;
+                    planStateVersion = mergedPlanState.version;
                     lastPlanStateSignature = signature;
-                    currentPlanState = finalPlanState;
-                    for (const item of await emitPlanStateUpdate(options, currentAgentId, finalPlanState)) {
+                    currentPlanState = mergedPlanState;
+                    for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
                         yield item;
                     }
-                    const commentary = summarizePlanState(finalPlanState);
+                    for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, mergedPlanState)) {
+                        yield* emitCommentary(commentary);
+                    }
+                    const commentary = summarizePlanState(mergedPlanState);
                     if (commentary) {
                         yield* emitCommentary(commentary);
                     }
@@ -777,12 +876,16 @@ export async function* streamHarnessRun(options) {
                 const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
                 const signature = buildPlanStateSignature(reconciledPlanState);
                 if (signature !== lastPlanStateSignature) {
+                    const previousPlanState = currentPlanState;
                     planStateVersion = reconciledPlanState.version;
                     lastPlanStateSignature = signature;
                     currentPlanState = reconciledPlanState;
                     for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
                         yield item;
                     }
+                    for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, reconciledPlanState)) {
+                        yield* emitCommentary(commentary);
+                    }
                     const commentary = summarizePlanState(reconciledPlanState);
                     if (commentary) {
                         yield* emitCommentary(commentary);
@@ -791,6 +894,26 @@ export async function* streamHarnessRun(options) {
             }
         }
         currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
+        if (isSubstantiveTerminalAssistantOutput(assistantOutput) && planStateHasActiveItems(currentPlanState)) {
+            const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, "completed", new Date().toISOString());
+            const signature = buildPlanStateSignature(reconciledPlanState);
+            if (signature !== lastPlanStateSignature) {
+                const previousPlanState = currentPlanState;
+                planStateVersion = reconciledPlanState.version;
+                lastPlanStateSignature = signature;
+                currentPlanState = reconciledPlanState;
+                for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                    yield item;
+                }
+                for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, reconciledPlanState)) {
+                    yield* emitCommentary(commentary);
+                }
+                const commentary = summarizePlanState(reconciledPlanState);
+                if (commentary) {
+                    yield* emitCommentary(commentary);
+                }
+            }
+        }
         if (assistantOutputCameFromInvokeFallback
             && nonUpstreamStreamActivityObserved
             && planStateHasActiveItems(currentPlanState)) {
@@ -833,6 +956,67 @@ export async function* streamHarnessRun(options) {
         };
     }
     catch (error) {
+        const deterministicToolEvidenceOutput = resolveDeterministicFinalOutput({
+            visibleOutput: assistantOutput,
+            executedToolResults,
+        });
+        if (!assistantOutput && sawSuccessfulToolResult && deterministicToolEvidenceOutput) {
+            const terminalStructuredStatus = readTerminalStructuredStatus(deterministicToolEvidenceOutput);
+            if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
+                const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                const signature = buildPlanStateSignature(reconciledPlanState);
+                if (signature !== lastPlanStateSignature) {
+                    const previousPlanState = currentPlanState;
+                    planStateVersion = reconciledPlanState.version;
+                    lastPlanStateSignature = signature;
+                    currentPlanState = reconciledPlanState;
+                    for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                        yield item;
+                    }
+                    for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, reconciledPlanState)) {
+                        yield* emitCommentary(commentary);
+                    }
+                    const commentary = summarizePlanState(reconciledPlanState);
+                    if (commentary) {
+                        yield* emitCommentary(commentary);
+                    }
+                }
+            }
+            await options.appendAssistantMessage(options.sessionId, options.requestId, deterministicToolEvidenceOutput);
+            yield {
+                type: "event",
+                event: await options.emit(options.sessionId, options.requestId, 3, "output.delta", { content: deterministicToolEvidenceOutput }),
+            };
+            yield {
+                type: "content",
+                sessionId: options.sessionId,
+                requestId: options.requestId,
+                agentId: currentAgentId,
+                content: deterministicToolEvidenceOutput,
+            };
+            const completedEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "completed", {
+                previousState: "running",
+            });
+            yield {
+                type: "event",
+                event: completedEvent,
+            };
+            yield {
+                type: "result",
+                result: {
+                    sessionId: options.sessionId,
+                    requestId: options.requestId,
+                    agentId: currentAgentId,
+                    state: "completed",
+                    output: deterministicToolEvidenceOutput,
+                    finalMessageText: deterministicToolEvidenceOutput,
+                    metadata: {
+                        executedToolResults,
+                    },
+                },
+            };
+            return;
+        }
         const shouldRetryAfterStreamingCompatibilityError = !assistantOutput &&
             isOpenAICompatibleStreamingCompatibilityError(options.binding, error);
         if ((emitted || streamActivityObserved)

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

@@ -1,4 +1,4 @@
-export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
+export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
 export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_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";
 export { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, readTextContent, sanitizeVisibleText, } from "./output-content.js";
 export { isLikelyToolArgsObject, salvageToolArgs, tryParseJson, } from "./output-tool-args.js";

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

@@ -1,4 +1,4 @@
-export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
+export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
 export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_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";
 export { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, readTextContent, sanitizeVisibleText, } from "./output-content.js";
 export { isLikelyToolArgsObject, salvageToolArgs, tryParseJson, } from "./output-tool-args.js";

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

@@ -7,11 +7,20 @@ export declare function isRepairableWriteTodosEmptyFailure(error: unknown): bool
 export declare function isToolCallRecoveryFailure(error: unknown): boolean;
 export declare function isRetrySafeInvalidToolSelectionError(value: unknown): boolean;
 export declare function shouldValidateExecutionWithoutToolEvidence(request: unknown): boolean;
+export declare function shouldRequireVisibleTodoPlan(request: unknown): boolean;
+export declare function resolveMissingPlanRecoveryInstruction(params: {
+    request: unknown;
+    assistantText?: string;
+    hasPlanStateEvidence?: boolean;
+    hasWriteTodosEvidence?: boolean;
+    hasToolResultEvidence?: boolean;
+}): string | null;
 export declare function resolveExecutionWithoutToolEvidenceInstruction(request: unknown, result: unknown): string | null;
 export declare function resolveExecutionWithoutToolEvidenceTextInstruction(request: unknown, assistantText: string, toolCallEvidence?: boolean, resultEvidence?: {
     hasWriteTodosEvidence?: boolean;
     hasToolResultEvidence?: boolean;
     hasIncompletePlanState?: boolean;
+    hasPlanStateEvidence?: boolean;
     hasOpenTaskDelegation?: boolean;
     hasMissingDelegatedExecutionEvidence?: boolean;
 }): string | null;

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

@@ -1,4 +1,4 @@
-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 { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 import { wrapNormalizedMessage, readTextContent } from "./output-content.js";
 function collectRequestMessages(request) {
     if (typeof request !== "object" || !request || Array.isArray(request)) {
@@ -111,6 +111,41 @@ export function shouldValidateExecutionWithoutToolEvidence(request) {
     }
     return readSystemInstructionText(request).length > 0;
 }
+export function shouldRequireVisibleTodoPlan(request) {
+    const userText = readLatestUserRequestText(request).toLowerCase();
+    if (!userText) {
+        return false;
+    }
+    return [
+        "investigate",
+        "investigation",
+        "issue",
+        "issues",
+        "rca",
+        "root cause",
+        "go deeper",
+        "deep research",
+        "debug",
+        "排查",
+        "调查",
+        "问题",
+        "根因",
+        "故障",
+        "集群",
+        "cluster",
+    ].some((keyword) => userText.includes(keyword));
+}
+export function resolveMissingPlanRecoveryInstruction(params) {
+    const hasPlanEvidence = params.hasWriteTodosEvidence === true
+        || params.hasPlanStateEvidence === true;
+    if (!shouldRequireVisibleTodoPlan(params.request) || hasPlanEvidence) {
+        return null;
+    }
+    if (params.hasToolResultEvidence === true) {
+        return WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION;
+    }
+    return null;
+}
 export function resolveExecutionWithoutToolEvidenceInstruction(request, result) {
     const assistantText = readTextContent(result).trim();
     return resolveExecutionWithoutToolEvidenceTextInstruction(request, assistantText, false, {});
@@ -120,6 +155,16 @@ export function resolveExecutionWithoutToolEvidenceTextInstruction(request, assi
         return null;
     }
     const normalizedText = assistantText.trim();
+    const missingPlanRecoveryInstruction = resolveMissingPlanRecoveryInstruction({
+        request,
+        assistantText: normalizedText,
+        hasWriteTodosEvidence: resultEvidence.hasWriteTodosEvidence,
+        hasPlanStateEvidence: resultEvidence.hasIncompletePlanState === true || resultEvidence.hasPlanStateEvidence === true,
+        hasToolResultEvidence: resultEvidence.hasToolResultEvidence,
+    });
+    if (missingPlanRecoveryInstruction) {
+        return missingPlanRecoveryInstruction;
+    }
     const hasUnfinishedExecution = resultEvidence.hasIncompletePlanState === true
         || resultEvidence.hasOpenTaskDelegation === true
         || resultEvidence.hasMissingDelegatedExecutionEvidence === true;

package/dist/runtime/support/compiled-binding.d.ts

@@ -31,6 +31,11 @@ export declare function getBindingDeepAgentSubagents(binding: CompiledAgentBindi
 export declare function getBindingGeneralPurposeAgent(binding: CompiledAgentBinding): boolean | undefined;
 export declare function getBindingTaskDescription(binding: CompiledAgentBinding): string | undefined;
 export declare function getBindingBackendConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
+export declare function getBindingInteractionMode(binding: CompiledAgentBinding): "stream" | "invoke" | undefined;
+export declare function getBindingBuiltinToolsConfig(binding: CompiledAgentBinding): {
+    filesystem?: boolean;
+    todos?: boolean;
+} | undefined;
 export declare function getBindingFilesystemConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
 export declare function isLangChainBinding(binding: CompiledAgentBinding): boolean;
 export declare function isDeepAgentBinding(binding: CompiledAgentBinding): boolean;

package/dist/runtime/support/compiled-binding.js

@@ -229,6 +229,18 @@ export function getBindingBackendConfig(binding) {
     const backend = execution?.backend;
     return typeof backend === "object" && backend ? backend : undefined;
 }
+export function getBindingInteractionMode(binding) {
+    const execution = getBindingExecutionParams(binding);
+    const mode = execution?.interactionMode;
+    return mode === "invoke" || mode === "stream" ? mode : undefined;
+}
+export function getBindingBuiltinToolsConfig(binding) {
+    const execution = getBindingExecutionParams(binding);
+    const builtinTools = execution?.builtinTools;
+    return typeof builtinTools === "object" && builtinTools
+        ? builtinTools
+        : undefined;
+}
 export function getBindingFilesystemConfig(binding) {
     const langchainFilesystem = binding.harnessRuntime?.langchain?.filesystem;
     if (typeof langchainFilesystem === "object" && langchainFilesystem) {

package/dist/workspace/agent-binding-compiler.js

@@ -169,6 +169,7 @@ export function requireTools(tools, bindings, ownerId) {
 function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parentModel) {
     const execution = compileExecutionCore(agent, workspaceRoot, models, tools);
     return {
+        agentId: agent.id,
         name: resolveAgentRuntimeName(agent),
         description: agent.description,
         systemPrompt: execution.systemPrompt ?? WORKSPACE_BOUNDARY_GUIDANCE,
@@ -178,6 +179,7 @@ function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parent
         skills: compileAgentSkills(workspaceRoot, agent, parentSkills),
         responseFormat: execution.responseFormat,
         middleware: execution.middleware,
+        builtinTools: getAgentExecutionObject(agent, "builtinTools"),
     };
 }
 function resolveSystemPrompt(agent, workspaceRoot) {
@@ -484,6 +486,12 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             name: resolveAgentRuntimeName(agent),
             memory: compiledAgentMemory,
             skills: compiledAgentSkills,
+            interactionMode: getAgentExecutionConfigValue(agent, "interactionMode", { executionMode: "deepagent" }) === "invoke"
+                ? "invoke"
+                : getAgentExecutionConfigValue(agent, "interactionMode", { executionMode: "deepagent" }) === "stream"
+                    ? "stream"
+                    : undefined,
+            builtinTools: getAgentExecutionObject(agent, "builtinTools"),
         },
     };
     return attachLegacyExecutionAliases({

package/dist/workspace/object-loader.js

@@ -27,6 +27,8 @@ const CONSUMED_AGENT_CONFIG_KEYS = [
     "taskDescription",
     "generalPurposeAgent",
     "filesystem",
+    "builtinTools",
+    "interactionMode",
 ];
 const NON_AGENT_CONFIG_ITEM_KEYS = [
     "id",
@@ -61,6 +63,8 @@ const MIGRATED_AGENT_CONFIG_KEYS = [
     "taskDescription",
     "generalPurposeAgent",
     "filesystem",
+    "builtinTools",
+    "interactionMode",
 ];
 function normalizeAgentItemForMerge(item) {
     const normalized = { ...item };
@@ -223,6 +227,7 @@ function resolveExecutionBackend(item, current) {
 function readSharedAgentConfigFields(config, options = {}) {
     return {
         ...(typeof config.store === "object" && config.store ? { store: config.store } : {}),
+        ...(typeof config.builtinTools === "object" && config.builtinTools ? { builtinTools: cloneConfigValue(config.builtinTools) } : {}),
         ...(options.includeDelegationControls && typeof config.taskDescription === "string" && config.taskDescription.trim()
             ? { taskDescription: config.taskDescription }
             : {}),
@@ -258,6 +263,7 @@ function readSharedAgentConfig(config) {
         ...(config.stateSchema !== undefined ? { stateSchema: config.stateSchema } : {}),
         ...(config.responseFormat !== undefined ? { responseFormat: config.responseFormat } : {}),
         ...(config.contextSchema !== undefined ? { contextSchema: config.contextSchema } : {}),
+        ...(config.interactionMode === "stream" || config.interactionMode === "invoke" ? { interactionMode: config.interactionMode } : {}),
         ...(config.includeAgentName === "inline" ? { includeAgentName: "inline" } : {}),
         ...(config.version === "v1" || config.version === "v2" ? { version: config.version } : {}),
         ...(typeof config.filesystem === "object" && config.filesystem ? { filesystem: config.filesystem } : {}),

package/package.json

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