@botbotgo/agent-harness 0.0.404 → 0.0.406

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.404";
+export declare const AGENT_HARNESS_VERSION = "0.0.406";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-02";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.404";
+export const AGENT_HARNESS_VERSION = "0.0.406";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-02";

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

@@ -708,7 +708,9 @@ export async function* streamRuntimeExecution(options) {
             }
             const streamedDelegatedRecoveryInstruction = resolveDelegatedExecutionRecoveryInstruction(streamedExecutionEvidence);
             const streamedDelegationOnlyRecoveryInstruction = resolveDelegationOnlyRecoveryInstruction(options.binding, streamedExecutionEvidence);
-            const streamedIncompletePlanRecoveryInstruction = requiresPlanEvidence(options.binding) && streamedExecutionEvidence.hasIncompletePlanState
+            const streamedIncompletePlanRecoveryInstruction = requiresPlanEvidence(options.binding)
+                && streamedExecutionEvidence.hasIncompletePlanState
+                && streamedExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence
                 ? CLOSE_REQUIRED_PLAN_RECOVERY_INSTRUCTION
                 : null;
             const streamedPrematurePlanCloseRecoveryInstruction = requiresPlanEvidence(options.binding)
@@ -721,7 +723,8 @@ export async function* streamRuntimeExecution(options) {
                 : null;
             if (hasUnresolvedExecution(streamedExecutionEvidence)
                 && !delegatedExecutionRecoveryInstruction
-                && !streamedIncompletePlanRecoveryInstruction) {
+                && !streamedIncompletePlanRecoveryInstruction
+                && !streamedPrematurePlanCloseRecoveryInstruction) {
                 throw createUnresolvedExecutionError(streamedExecutionEvidence);
             }
             const executionWithoutToolEvidenceInstruction = projectionState.emittedOutput
@@ -968,10 +971,18 @@ export async function* streamRuntimeExecution(options) {
             })
             : null;
         const invokeFallbackDelegationOnlyRecoveryInstruction = resolveDelegationOnlyRecoveryInstruction(options.binding, invokeExecutionEvidence);
-        const invokeFallbackIncompletePlanRecoveryInstruction = requiresPlanEvidence(options.binding) && invokeExecutionEvidence.hasIncompletePlanState
+        const invokeFallbackIncompletePlanRecoveryInstruction = requiresPlanEvidence(options.binding)
+            && invokeExecutionEvidence.hasIncompletePlanState
+            && invokeExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence
             ? CLOSE_REQUIRED_PLAN_RECOVERY_INSTRUCTION
             : null;
+        const invokeFallbackPlanWithoutEvidenceRecoveryInstruction = requiresPlanEvidence(options.binding)
+            && invokeExecutionEvidence.hasPlanStateEvidence
+            && !invokeExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence
+            ? RUN_EVIDENCE_AFTER_PREMATURE_PLAN_CLOSE_INSTRUCTION
+            : null;
         const effectiveInvokeFallbackRecoveryInstruction = invokeFallbackIncompletePlanRecoveryInstruction
+            ?? invokeFallbackPlanWithoutEvidenceRecoveryInstruction
             ?? invokeFallbackMissingPlanRecoveryInstruction
             ?? invokeFallbackDelegationOnlyRecoveryInstruction
             ?? invokeFallbackRecoveryInstruction;

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

@@ -10,9 +10,6 @@ import { appendToolRecoveryInstruction, extractVisibleOutput, resolveMissingPlan
 import { salvageJsonToolCalls } from "../parsing/output-tool-args.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 isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function readPlanStateSummary(output) {
     if (typeof output !== "object" || output === null) {
         return null;
@@ -61,159 +58,6 @@ function isFallbackTodoCompletionToolCall(toolCall) {
         && toolCall.id.startsWith("fallback-complete-")
         && (toolCall.name === "write_todos" || toolCall.name === "tool_call_write_todos");
 }
-function isTerminalTodoUpdateToolCall(toolCall) {
-    if (!isPlanToolName(toolCall.name) || normalizeToolName(toolCall.name).includes("read_todos")) {
-        return false;
-    }
-    if (typeof toolCall.args !== "object" || toolCall.args === null || !Array.isArray(toolCall.args.todos)) {
-        return false;
-    }
-    const todos = toolCall.args.todos;
-    return todos.length > 0 && todos.every((todo) => {
-        if (typeof todo !== "object" || todo === null || typeof todo.status !== "string") {
-            return false;
-        }
-        const status = todo.status.trim().toLowerCase();
-        return status !== "pending" && status !== "in_progress";
-    });
-}
-function readSchemaShape(schema) {
-    if (!isObject(schema)) {
-        return null;
-    }
-    if (isObject(schema.properties)) {
-        return schema.properties;
-    }
-    if (isObject(schema.shape)) {
-        return schema.shape;
-    }
-    const def = schema._def;
-    if (!def) {
-        return null;
-    }
-    const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-    return isObject(shape) ? shape : null;
-}
-function readSchemaDescription(schemaPart) {
-    if (!isObject(schemaPart)) {
-        return "";
-    }
-    const direct = schemaPart.description;
-    if (typeof direct === "string") {
-        return direct;
-    }
-    const nested = schemaPart._def;
-    if (typeof nested?.description === "string") {
-        return nested.description;
-    }
-    return readSchemaDescription(nested?.innerType);
-}
-function readSchemaDefault(schemaPart) {
-    if (!isObject(schemaPart)) {
-        return undefined;
-    }
-    const typed = schemaPart;
-    const hasJsonDefault = Object.prototype.hasOwnProperty.call(schemaPart, "default") && typeof typed.default !== "function";
-    if (hasJsonDefault) {
-        return typed.default;
-    }
-    if (Object.prototype.hasOwnProperty.call(schemaPart, "const")) {
-        return typed.const;
-    }
-    const def = schemaPart._def;
-    if (!def) {
-        return undefined;
-    }
-    if (def.defaultValue !== undefined) {
-        return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
-    }
-    return readSchemaDefault(def.innerType);
-}
-function parseFirstStringArrayExample(description) {
-    const arrayMatch = description.match(/\[[^\]]+\]/u);
-    if (!arrayMatch) {
-        return null;
-    }
-    const values = [...arrayMatch[0].matchAll(/["']([^"']+)["']/gu)].map((match) => match[1]).filter(Boolean);
-    return values.length > 0 ? values : null;
-}
-function buildGenericFallbackArgsFromSchema(schema, latestUserInput) {
-    const shape = readSchemaShape(schema);
-    if (!shape) {
-        return {};
-    }
-    const args = {};
-    for (const [key, schemaPart] of Object.entries(shape)) {
-        const defaultValue = readSchemaDefault(schemaPart);
-        if (defaultValue !== undefined) {
-            args[key] = defaultValue;
-            continue;
-        }
-        const description = readSchemaDescription(schemaPart);
-        const arrayExample = parseFirstStringArrayExample(description);
-        if (arrayExample) {
-            args[key] = arrayExample;
-            continue;
-        }
-        if (latestUserInput
-            && !args[key]
-            && /(?:query|question|prompt|input|text)/iu.test(`${key} ${description}`)) {
-            args[key] = latestUserInput;
-        }
-    }
-    return args;
-}
-function readTodoPlanTextFromToolCalls(toolCalls) {
-    const fragments = [];
-    for (const toolCall of toolCalls) {
-        if (typeof toolCall.args !== "object" || toolCall.args === null) {
-            continue;
-        }
-        const todos = toolCall.args.todos;
-        if (!Array.isArray(todos)) {
-            continue;
-        }
-        for (const todo of todos) {
-            if (typeof todo === "object" && todo !== null && typeof todo.content === "string") {
-                fragments.push(todo.content);
-            }
-        }
-    }
-    return fragments.join("\n");
-}
-function selectGenericFallbackEvidenceTool(params) {
-    const candidates = [];
-    const appendCandidate = (name) => {
-        if (isPlanToolName(name)) {
-            return;
-        }
-        const resolved = resolveModelFacingToolName(name, params.toolNameMapping, params.primaryTools);
-        const executable = params.executableTools.get(name)
-            ?? params.executableTools.get(resolved)
-            ?? params.builtinExecutableTools.get(name)
-            ?? params.builtinExecutableTools.get(resolved);
-        if (!executable || candidates.some((candidate) => candidate.executable.name === executable.name)) {
-            return;
-        }
-        candidates.push({ requestedName: name, executable });
-    };
-    for (const tool of params.primaryTools) {
-        appendCandidate(tool.name);
-        const modelFacing = params.toolNameMapping.originalToModelFacing.get(tool.name);
-        if (modelFacing) {
-            appendCandidate(modelFacing);
-        }
-    }
-    for (const name of [...params.executableTools.keys(), ...params.builtinExecutableTools.keys()]) {
-        appendCandidate(name);
-    }
-    if (candidates.length === 0) {
-        return null;
-    }
-    const normalizedPlanText = params.planText.toLowerCase();
-    return candidates.find((candidate) => normalizedPlanText.includes(candidate.requestedName.toLowerCase())
-        || normalizedPlanText.includes(candidate.executable.name.toLowerCase())) ?? candidates[0];
-}
 function buildDeterministicFinalFromToolEvidence(executedToolResults) {
     const evidence = executedToolResults
         .filter((item) => item.isError !== true && item.toolName !== "write_todos" && item.toolName !== "read_todos")
@@ -294,19 +138,12 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             const hasIncompletePlanState = hasIncompleteExecutedPlan(executedToolResults);
             const shouldEnforceIncompletePlan = requiresPlanEvidence(binding) && hasIncompletePlanState;
             const hasExecutionBeyondTodoPlanning = hasNonTodoToolEvidence(executedToolResults);
-            const missingInitialPlanRecoveryInstruction = resolveMissingPlanRecoveryInstruction({
-                request: activeRequest,
-                requiresPlan: requiresPlanEvidence(binding),
-                hasPlanStateEvidence: hasPlanStateEvidence(executedToolResults),
-                hasWriteTodosEvidence: executedToolResults.some((item) => item.toolName === "write_todos"),
-                hasToolResultEvidence: hasExecutionBeyondTodoPlanning,
-            });
             const toolErrorRecoveryInstruction = latestToolErrorRecoveryInstruction(executedToolResults)
                 ?? terminalToolErrorRecoveryInstruction(terminalText);
             const leakedJsonToolCallRecoveryInstruction = terminalText && salvageJsonToolCalls(terminalText).length > 0
                 ? STRICT_TOOL_JSON_INSTRUCTION
                 : null;
-            const recoveryInstruction = toolErrorRecoveryInstruction ?? leakedJsonToolCallRecoveryInstruction ?? missingInitialPlanRecoveryInstruction ?? (terminalText
+            const recoveryInstruction = toolErrorRecoveryInstruction ?? leakedJsonToolCallRecoveryInstruction ?? (terminalText
                 ? resolveExecutionWithoutToolEvidenceTextInstruction(activeRequest, terminalText, false, {
                     hasWriteTodosEvidence: executedToolResults.some((item) => item.toolName === "write_todos"),
                     hasToolResultEvidence: hasExecutionBeyondTodoPlanning,
@@ -415,53 +252,6 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 content: stringifyToolOutput(safeToolResult),
             }));
         }
-        if (requiresPlanEvidence(binding)
-            && !hadNonTodoEvidenceBeforeToolReplay
-            && !hasNonTodoToolEvidence(executedToolResults)
-            && toolCalls.length > 0
-            && toolCalls.every((toolCall) => isPlanToolName(toolCall.name))
-            && toolCalls.some(isTerminalTodoUpdateToolCall)) {
-            const fallbackEvidenceTool = selectGenericFallbackEvidenceTool({
-                planText: readTodoPlanTextFromToolCalls(toolCalls),
-                primaryTools,
-                toolNameMapping,
-                executableTools,
-                builtinExecutableTools,
-            });
-            if (fallbackEvidenceTool) {
-                const fallbackArgs = buildGenericFallbackArgsFromSchema(fallbackEvidenceTool.executable.schema, latestUserInput);
-                const normalizedArgs = normalizeToolArgsForSchema(fallbackArgs, fallbackEvidenceTool.executable.schema, undefined, {
-                    latestUserInput,
-                });
-                const compiledTool = toolCatalog.get(fallbackEvidenceTool.requestedName) ?? toolCatalog.get(fallbackEvidenceTool.executable.name);
-                const gateway = validateToolGatewayInput({
-                    toolName: fallbackEvidenceTool.executable.name,
-                    schema: fallbackEvidenceTool.executable.schema,
-                    args: normalizedArgs,
-                    requiresApproval: compiledTool ? toolRequiresRuntimeApproval(compiledTool) : false,
-                });
-                if (gateway.ok) {
-                    const toolResult = toolRuntimeContext
-                        ? await fallbackEvidenceTool.executable.invoke(gateway.input, { toolRuntimeContext })
-                        : await fallbackEvidenceTool.executable.invoke(gateway.input);
-                    const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
-                    const safeToolResult = await maybePersistLargeToolOutput({
-                        toolName: fallbackEvidenceTool.executable.name,
-                        output: toolResult,
-                        toolRuntimeContext: toolRuntimeContext,
-                    });
-                    executedToolResults.push({
-                        toolName: fallbackEvidenceTool.executable.name,
-                        output: safeToolResult,
-                        ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
-                    });
-                    return {
-                        result: buildDeterministicFinalFromToolEvidence(executedToolResults),
-                        executedToolResults,
-                    };
-                }
-            }
-        }
         if (requiresPlanEvidence(binding)
             && toolCalls.length > 0
             && toolCalls.every((toolCall) => isPlanToolName(toolCall.name))

package/dist/runtime/adapter/model/model-providers.js

@@ -253,26 +253,6 @@ function readLatestToolResultContent(input) {
     }
     return null;
 }
-function readLatestUserContent(input) {
-    if (Array.isArray(input)) {
-        for (let index = input.length - 1; index >= 0; index -= 1) {
-            const message = input[index];
-            if (mapMessageRole(message) !== "USER") {
-                continue;
-            }
-            const content = readPromptContent(message).trim();
-            if (content) {
-                return content;
-            }
-        }
-        return undefined;
-    }
-    if (typeof input === "object" && input !== null && Array.isArray(input.messages)) {
-        return readLatestUserContent(input.messages);
-    }
-    const content = readPromptContent(input).trim();
-    return content || undefined;
-}
 function readBoundToolName(tool) {
     return typeof tool === "object" && tool !== null && typeof tool.name === "string"
         ? tool.name.trim()
@@ -598,33 +578,10 @@ function isLowSignalPlanningLine(value) {
         || /^#+\s*/.test(normalized)
         || /^(?:ok|okay|sure|understood|got it|plan|todo|steps?)\.?$/.test(normalized));
 }
-function normalizeDomainToolName(name) {
-    return name.startsWith("tool_call_") ? name.slice("tool_call_".length) : name;
-}
-function selectFallbackEvidenceToolName(tools, rawText = "") {
-    const normalizedRawText = rawText.toLowerCase();
-    const available = tools
-        .map((tool) => normalizeDomainToolName(readBoundToolName(tool)))
-        .filter((name) => name && !isTodoPlanningToolName(name) && !isTodoPlanningToolName(`tool_call_${name}`));
-    if (available.length === 0) {
-        return null;
-    }
-    const mentioned = available.find((name) => normalizedRawText.includes(name.toLowerCase()));
-    return mentioned ?? available[0] ?? null;
-}
-function buildToolAwareFallbackTodoContents(tools, rawText = "") {
-    const evidenceToolName = selectFallbackEvidenceToolName(tools, rawText);
-    if (!evidenceToolName) {
-        return [
-            "Identify the concrete evidence tool required for this request",
-            "Run the selected non-planning evidence tool and inspect its result",
-            "Update TODO status from the observed evidence",
-            "Return the final answer grounded in tool output",
-        ];
-    }
+function buildFallbackTodoContents() {
     return [
-        `Run ${evidenceToolName} for the requested evidence`,
-        `Inspect the ${evidenceToolName} result and extract concrete findings`,
+        "Identify the concrete evidence tool required for this request",
+        "Run the selected non-planning evidence tool and inspect its result",
         "Update TODO status from the observed evidence",
         "Return the final answer grounded in tool output",
     ];
@@ -632,7 +589,7 @@ function buildToolAwareFallbackTodoContents(tools, rawText = "") {
 function isGenericFallbackTodoContent(value) {
     return /^(?:gather concrete evidence|inspect the most relevant runtime signals|analyze (?:the )?evidence|produce the final rca)/i.test(value.trim());
 }
-function buildFallbackPlanningToolCall(input, planningTools, allTools, rawText) {
+function buildFallbackPlanningToolCall(input, planningTools, rawText) {
     const toolName = planningTools.map((tool) => readBoundToolName(tool)).find((name) => name === "write_todos" || name === "tool_call_write_todos");
     if (!toolName) {
         return null;
@@ -641,7 +598,7 @@ function buildFallbackPlanningToolCall(input, planningTools, allTools, rawText)
     const hasUsefulModelPlan = modelPlannedItems.length >= 2 && !modelPlannedItems.every(isGenericFallbackTodoContent);
     const fallbackItems = hasUsefulModelPlan
         ? modelPlannedItems
-        : buildToolAwareFallbackTodoContents(allTools, rawText);
+        : buildFallbackTodoContents();
     const todos = fallbackItems.map((content, index) => ({
         content,
         status: index === 0 ? "in_progress" : "pending",
@@ -656,63 +613,6 @@ function buildFallbackPlanningToolCall(input, planningTools, allTools, rawText)
             }],
     });
 }
-function buildFallbackEvidenceToolArgs(tool, latestUserInput) {
-    const schema = normalizeModelFacingToolSchema(tool);
-    if (typeof schema.properties !== "object" || schema.properties === null || Array.isArray(schema.properties)) {
-        return {};
-    }
-    const required = Array.isArray(schema.required)
-        ? schema.required.filter((name) => typeof name === "string")
-        : [];
-    const values = {};
-    for (const [key, value] of Object.entries(schema.properties)) {
-        if (typeof value !== "object" || value === null || Array.isArray(value)) {
-            continue;
-        }
-        const property = value;
-        if ("default" in property) {
-            values[key] = property.default;
-            continue;
-        }
-        if ("const" in property) {
-            values[key] = property.const;
-            continue;
-        }
-        if (required.includes(key) && Array.isArray(property.enum) && property.enum.length > 0) {
-            values[key] = property.enum[0];
-            continue;
-        }
-        if (latestUserInput
-            && !values[key]
-            && /(?:query|question|prompt|input|text)/iu.test(`${key} ${typeof property.description === "string" ? property.description : ""}`)) {
-            values[key] = latestUserInput;
-        }
-    }
-    return values;
-}
-function buildFallbackEvidenceToolCall(input, tools, rawText = "") {
-    if (!hasPriorToolResultForToolName(input, "write_todos") && !hasPriorToolResultForToolName(input, "tool_call_write_todos")) {
-        return null;
-    }
-    const evidenceToolName = selectFallbackEvidenceToolName(tools, rawText);
-    if (!evidenceToolName) {
-        return null;
-    }
-    const boundTool = tools.find((tool) => normalizeDomainToolName(readBoundToolName(tool)) === evidenceToolName);
-    const boundToolName = readBoundToolName(boundTool);
-    if (!boundTool || !boundToolName || hasPriorToolResultForToolName(input, boundToolName) || hasPriorToolResultForToolName(input, evidenceToolName)) {
-        return null;
-    }
-    return new AIMessage({
-        content: "",
-        tool_calls: [{
-                id: `fallback-evidence-${Math.random().toString(36).slice(2, 10)}`,
-                name: boundToolName,
-                args: buildFallbackEvidenceToolArgs(boundTool, readLatestUserContent(input)),
-                type: "tool_call",
-            }],
-    });
-}
 function buildFallbackTodoCompletionToolCall(input, tools) {
     const prompt = stringifyNodeLlamaCppInput(input);
     if (/TODO completed:|\[x\]/i.test(prompt)) {
@@ -722,17 +622,10 @@ function buildFallbackTodoCompletionToolCall(input, tools) {
     if (!planningToolName) {
         return null;
     }
-    const evidenceToolName = selectFallbackEvidenceToolName(tools, prompt);
-    if (!evidenceToolName) {
-        return null;
-    }
-    const hasEvidenceResult = hasPriorToolResultForToolName(input, evidenceToolName)
-        || hasPriorToolResultForToolName(input, `tool_call_${evidenceToolName}`)
-        || hasPriorNonPlanningToolResult(input, tools);
-    if (!hasEvidenceResult) {
+    if (!hasPriorNonPlanningToolResult(input, tools)) {
         return null;
     }
-    const todos = buildToolAwareFallbackTodoContents(tools, prompt).map((content) => ({
+    const todos = buildFallbackTodoContents().map((content) => ({
         content,
         status: "completed",
     }));
@@ -848,7 +741,7 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                     const parsedToolCall = normalizeParsedToolCall(extractToolCallPayload(text));
                     if (!parsedToolCall) {
                         if (forcePlanningToolCall) {
-                            const fallbackToolCall = buildFallbackPlanningToolCall(input, effectiveBoundTools, boundTools, text);
+                            const fallbackToolCall = buildFallbackPlanningToolCall(input, effectiveBoundTools, text);
                             if (fallbackToolCall) {
                                 return fallbackToolCall;
                             }
@@ -858,23 +751,12 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                             if (fallbackCompletionToolCall) {
                                 return fallbackCompletionToolCall;
                             }
-                            const fallbackToolCall = buildFallbackEvidenceToolCall(input, effectiveBoundTools, text);
-                            if (fallbackToolCall) {
-                                return fallbackToolCall;
-                            }
                         }
                         return rawResult;
                     }
                     const effectiveParsedToolCall = forcePlanningToolCall
                         ? normalizeInitialTodoPlanToolCall(parsedToolCall)
                         : parsedToolCall;
-                    if (parsedToolCallCompletesTodoPlan(effectiveParsedToolCall)
-                        && !hasPriorNonPlanningToolResult(input, effectiveBoundTools)) {
-                        const fallbackToolCall = buildFallbackEvidenceToolCall(input, effectiveBoundTools, text);
-                        if (fallbackToolCall) {
-                            return fallbackToolCall;
-                        }
-                    }
                     if (hasPriorToolResultForToolName(input, effectiveParsedToolCall.name) || hasAnyPriorToolResult(input)) {
                         return rawResult;
                     }

package/package.json

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