@botbotgo/agent-harness 0.0.401 → 0.0.403

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.401";
+export declare const AGENT_HARNESS_VERSION = "0.0.403";
 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.401";
+export const AGENT_HARNESS_VERSION = "0.0.403";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-02";

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

@@ -294,12 +294,19 @@ 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 ?? (terminalText
+            const recoveryInstruction = toolErrorRecoveryInstruction ?? leakedJsonToolCallRecoveryInstruction ?? missingInitialPlanRecoveryInstruction ?? (terminalText
                 ? resolveExecutionWithoutToolEvidenceTextInstruction(activeRequest, terminalText, false, {
                     hasWriteTodosEvidence: executedToolResults.some((item) => item.toolName === "write_todos"),
                     hasToolResultEvidence: hasExecutionBeyondTodoPlanning,

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

@@ -253,6 +253,26 @@ 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()
@@ -636,7 +656,7 @@ function buildFallbackPlanningToolCall(input, planningTools, allTools, rawText)
             }],
     });
 }
-function buildFallbackEvidenceToolArgs(tool) {
+function buildFallbackEvidenceToolArgs(tool, latestUserInput) {
     const schema = normalizeModelFacingToolSchema(tool);
     if (typeof schema.properties !== "object" || schema.properties === null || Array.isArray(schema.properties)) {
         return {};
@@ -660,6 +680,12 @@ function buildFallbackEvidenceToolArgs(tool) {
         }
         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;
@@ -682,7 +708,7 @@ function buildFallbackEvidenceToolCall(input, tools, rawText = "") {
         tool_calls: [{
                 id: `fallback-evidence-${Math.random().toString(36).slice(2, 10)}`,
                 name: boundToolName,
-                args: buildFallbackEvidenceToolArgs(boundTool),
+                args: buildFallbackEvidenceToolArgs(boundTool, readLatestUserContent(input)),
                 type: "tool_call",
             }],
     });

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -38,6 +38,8 @@ export declare class AgentRuntimeAdapter {
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
     private materializeProviderAliasBuiltinTools;
+    private shouldExposeBuiltinToolsToModel;
+    private resolveEffectiveModelExposedBuiltins;
     private materializeAutomaticSummarizationMiddleware;
     private resolveLangChainRuntimeExtensionMiddleware;
     private resolveMiddleware;

package/dist/runtime/agent-runtime-adapter.js

@@ -694,12 +694,47 @@ export class AgentRuntimeAdapter {
             invokeBuiltinTaskTool: assembly.invokeBuiltinTaskTool,
         });
     }
-    materializeProviderAliasBuiltinTools(builtinTools) {
+    materializeProviderAliasBuiltinTools(builtinTools, modelExposed) {
+        if (modelExposed === false) {
+            return [];
+        }
+        const allowedToolNames = Array.isArray(modelExposed) ? new Set(modelExposed) : undefined;
         const aliasableTools = ["write_todos", "read_todos", "task"]
+            .filter((name) => !allowedToolNames || allowedToolNames.has(name))
             .map((name) => builtinTools.get(name))
             .filter((tool) => tool !== undefined);
         return appendProviderToolCallAliasTools(aliasableTools).slice(aliasableTools.length);
     }
+    shouldExposeBuiltinToolsToModel(binding, primaryTools) {
+        const modelExposed = getBindingBuiltinToolsConfig(binding)?.modelExposed;
+        if (binding.harnessRuntime.executionContract?.requiresPlan === true) {
+            return true;
+        }
+        if (modelExposed === false) {
+            return false;
+        }
+        if (Array.isArray(modelExposed)) {
+            return modelExposed.length > 0;
+        }
+        return (primaryTools.length > 0
+            || getBindingSubagents(binding).length > 0
+            || getBindingDeepAgentSubagents(binding).length > 0);
+    }
+    resolveEffectiveModelExposedBuiltins(binding) {
+        const configured = getBindingBuiltinToolsConfig(binding)?.modelExposed;
+        const requiredNames = new Set();
+        if (binding.harnessRuntime.executionContract?.requiresPlan === true) {
+            requiredNames.add("write_todos");
+            requiredNames.add("read_todos");
+        }
+        if (configured === false) {
+            return requiredNames.size > 0 ? [...requiredNames] : false;
+        }
+        if (Array.isArray(configured)) {
+            return [...new Set([...configured, ...requiredNames])];
+        }
+        return configured;
+    }
     async materializeAutomaticSummarizationMiddleware(binding) {
         const assembly = this.createAssemblyResolvers(binding);
         return materializeAutomaticSummarizationMiddlewareHelper({
@@ -818,12 +853,18 @@ export class AgentRuntimeAdapter {
                 sessionId: options.sessionId ?? options.legacySessionId,
             }),
         });
-        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: builtinExecutableTools,
-            explicitToolNames: primaryTools.map((tool) => tool.name),
-            modelExposed: getBindingBuiltinToolsConfig(binding)?.modelExposed,
-        });
-        const providerAliasBuiltinTools = this.materializeProviderAliasBuiltinTools(builtinExecutableTools);
+        const modelExposedBuiltins = this.resolveEffectiveModelExposedBuiltins(binding);
+        const shouldExposeBuiltinTools = this.shouldExposeBuiltinToolsToModel(binding, primaryTools);
+        const builtinMiddlewareTools = shouldExposeBuiltinTools
+            ? materializeModelExposedBuiltinMiddlewareTools({
+                builtinTools: builtinExecutableTools,
+                explicitToolNames: primaryTools.map((tool) => tool.name),
+                modelExposed: modelExposedBuiltins,
+            })
+            : [];
+        const providerAliasBuiltinTools = shouldExposeBuiltinTools
+            ? this.materializeProviderAliasBuiltinTools(builtinExecutableTools, modelExposedBuiltins)
+            : [];
         const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { sessionId: options.sessionId ?? options.legacySessionId });
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
         const resolvedStore = this.options.storeResolver?.(binding);
@@ -870,12 +911,18 @@ export class AgentRuntimeAdapter {
                 sessionId: options.sessionId ?? options.legacySessionId,
             }),
         });
-        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: builtinExecutableTools,
-            explicitToolNames: primaryTools.map((tool) => tool.name),
-            modelExposed: getBindingBuiltinToolsConfig(binding)?.modelExposed,
-        });
-        const providerAliasBuiltinTools = this.materializeProviderAliasBuiltinTools(builtinExecutableTools);
+        const modelExposedBuiltins = this.resolveEffectiveModelExposedBuiltins(binding);
+        const shouldExposeBuiltinTools = this.shouldExposeBuiltinToolsToModel(binding, primaryTools);
+        const builtinMiddlewareTools = shouldExposeBuiltinTools
+            ? materializeModelExposedBuiltinMiddlewareTools({
+                builtinTools: builtinExecutableTools,
+                explicitToolNames: primaryTools.map((tool) => tool.name),
+                modelExposed: modelExposedBuiltins,
+            })
+            : [];
+        const providerAliasBuiltinTools = shouldExposeBuiltinTools
+            ? this.materializeProviderAliasBuiltinTools(builtinExecutableTools, modelExposedBuiltins)
+            : [];
         const modelTools = [
             ...appendProviderToolCallAliasTools([...resolvedTools, ...builtinMiddlewareTools]),
             ...providerAliasBuiltinTools,

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

@@ -118,10 +118,7 @@ export function resolveMissingPlanRecoveryInstruction(params) {
     if (params.requiresPlan !== true || hasPlanEvidence) {
         return null;
     }
-    if (params.hasToolResultEvidence === true) {
-        return WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION;
-    }
-    return null;
+    return WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION;
 }
 export function resolveExecutionWithoutToolEvidenceInstruction(request, result) {
     const assistantText = readTextContent(result).trim();

package/package.json

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