@botbotgo/agent-harness 0.0.441 → 0.0.443

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.441";
+export declare const AGENT_HARNESS_VERSION = "0.0.443";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.441";
+export const AGENT_HARNESS_VERSION = "0.0.443";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

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

@@ -3,6 +3,7 @@ import { buildBindingToolExecutionContext } from "./execution-context.js";
 import { finalizeRequestResult } from "../invocation-result.js";
 import { invokeRuntimeWithLocalTools } from "./invoke-runtime.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
+import { withPromptedJsonToolPolicy } from "../model/prompted-json-tool-policy.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../upstream-configurable-keys.js";
 import { appendToolRecoveryInstruction, extractVisibleOutput, tryParseJson } from "../../parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
@@ -311,7 +312,7 @@ export async function executeRequestInvocation(options) {
     if (options.resumePayload === undefined
         && options.binding.harnessRuntime.executionContract?.requiresPlan === true
         && invokeOptions.suppressInitialRequiredPlanInstruction !== true) {
-        request = appendToolRecoveryInstruction(request, INITIAL_REQUIRED_PLAN_INSTRUCTION);
+        request = withPromptedJsonToolPolicy(appendToolRecoveryInstruction(request, INITIAL_REQUIRED_PLAN_INSTRUCTION), "planning");
     }
     const { primaryTools, toolNameMapping, executableTools, defersToUpstreamHitlExecution, } = buildBindingToolExecutionContext({
         binding: options.binding,
@@ -368,7 +369,7 @@ export async function executeRequestInvocation(options) {
             ? result.messages
             : undefined;
         const recoveryBase = messages ? { messages } : request;
-        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION);
+        const recoveredRequest = withPromptedJsonToolPolicy(appendToolRecoveryInstruction(recoveryBase, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION), "planning");
         const recoveredInvocation = await invokeOnce(recoveredRequest);
         result = recoveredInvocation.result;
         executedToolResults.splice(0, executedToolResults.length, ...recoveredInvocation.executedToolResults);

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

@@ -1,6 +1,7 @@
 import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, appendToolRecoveryInstruction, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
 import { DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION, DELEGATION_ONLY_RECOVERY_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
+import { PROMPTED_JSON_TOOL_POLICY_KEY, withPromptedJsonToolPolicy } from "../model/prompted-json-tool-policy.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
 import { projectTextStreamChunks } from "../stream-text-consumption.js";
@@ -293,6 +294,15 @@ function withSuppressedInitialRequiredPlanInstruction(options) {
         suppressInitialRequiredPlanInstruction: true,
     };
 }
+function withNonPlanningEvidenceToolPolicy(options) {
+    return {
+        ...options,
+        state: {
+            ...(typeof options.state === "object" && options.state !== null ? options.state : {}),
+            [PROMPTED_JSON_TOOL_POLICY_KEY]: "nonPlanningEvidence",
+        },
+    };
+}
 function hasParentLocalToolExecutionAfterDelegationFailure(originalEvidence, executedToolResults) {
     return originalEvidence.hasFailedTaskDelegation
         && executedToolResults.some((item) => item.toolName !== "task");
@@ -575,7 +585,7 @@ function projectLocalToolExecutionProfileChunks(executedToolResults, prefix) {
 export async function* streamRuntimeExecution(options) {
     let request = buildInvocationRequest(options.binding, options.history, options.input, options.runtimeOptions);
     if (requiresPlanEvidence(options.binding)) {
-        request = appendToolRecoveryInstruction(request, buildInitialRequiredPlanInstruction(options.primaryTools));
+        request = withPromptedJsonToolPolicy(appendToolRecoveryInstruction(request, buildInitialRequiredPlanInstruction(options.primaryTools)), "planning");
     }
     let emittedUnsafeStreamSideEffects = false;
     const shouldProfile = options.runtimeOptions.profiling === true;
@@ -624,7 +634,11 @@ export async function* streamRuntimeExecution(options) {
                 yield modelStreamStart.chunk;
             let stream;
             try {
-                stream = await options.withTimeout(() => options.langChainStreamModel.stream(buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input, options.runtimeOptions.memoryContext)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
+                const rawStreamInput = buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input, options.runtimeOptions.memoryContext);
+                const streamInput = requiresPlanEvidence(options.binding)
+                    ? withPromptedJsonToolPolicy(rawStreamInput, "planning")
+                    : rawStreamInput;
+                stream = await options.withTimeout(() => options.langChainStreamModel.stream(streamInput), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
                 if (shouldProfile)
                     yield finishProfileStep({
                         id: "profile:agent:model-stream-start",
@@ -940,7 +954,7 @@ export async function* streamRuntimeExecution(options) {
                     if (earlyStreamRecoveryInstruction) {
                         const earlyRecoveryRuntimeOptions = earlyStreamRecoverySuppressInitialPlan
                             ? {
-                                ...withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions),
+                                ...withNonPlanningEvidenceToolPolicy(withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions)),
                                 externalPlanEvidence: true,
                                 ...(earlyStreamExternalPlanEvidenceTools && earlyStreamExternalPlanEvidenceTools.length > 0
                                     ? { externalPlanEvidenceTools: earlyStreamExternalPlanEvidenceTools }
@@ -1062,7 +1076,7 @@ export async function* streamRuntimeExecution(options) {
             if (retryInstruction) {
                 const retryRuntimeOptions = retryInstruction === streamedIncompletePlanRecoveryInstruction
                     || retryInstruction === streamedPrematurePlanCloseRecoveryInstruction
-                    ? withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions)
+                    ? withNonPlanningEvidenceToolPolicy(withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions))
                     : options.runtimeOptions;
                 let retried;
                 retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, retryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, retryRuntimeOptions);
@@ -1299,7 +1313,7 @@ export async function* streamRuntimeExecution(options) {
             const invokeFallbackRuntimeOptions = effectiveInvokeFallbackRecoveryInstruction === invokeFallbackIncompletePlanRecoveryInstruction
                 || effectiveInvokeFallbackRecoveryInstruction === invokeFallbackPlanWithoutEvidenceRecoveryInstruction
                 ? {
-                    ...withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions),
+                    ...withNonPlanningEvidenceToolPolicy(withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions)),
                     externalPlanEvidence: true,
                 }
                 : options.runtimeOptions;

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

@@ -10,6 +10,7 @@ import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
 import { normalizeModelFacingToolSchema } from "../tool/resolved-tool.js";
 import { normalizeOpenAICompatibleInit } from "../compat/openai-compatible.js";
 import { recordPromptedJsonToolCall } from "./prompted-json-tool-call-capture.js";
+import { readPromptedJsonToolPolicy } from "./prompted-json-tool-policy.js";
 const NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION = [
     "Available tools are listed below.",
     "If you need a tool, respond with only one JSON object.",
@@ -342,8 +343,7 @@ function hasPriorPlanningToolResult(input) {
         || hasPriorToolResultForToolName(input, "call_read_todos");
 }
 function shouldLimitToolsToPlanning(input, boundTools) {
-    const text = stringifyNodeLlamaCppInput(input);
-    return text.includes("required visible planning contract")
+    return readPromptedJsonToolPolicy(input) === "planning"
         && !hasPriorToolResultForToolName(input, "write_todos")
         && !hasPriorToolResultForToolName(input, "tool_call_write_todos")
         && !hasPriorToolResultForToolName(input, "call_write_todos")
@@ -357,9 +357,7 @@ function selectPlanningToolsForTurn(input, boundTools) {
     return planningTools.length > 0 ? planningTools : boundTools;
 }
 function shouldLimitToolsToNonPlanningEvidence(input, boundTools) {
-    const text = stringifyNodeLlamaCppInput(input);
-    const hasNonPlanningEvidenceInstruction = /non[-\s]?planning (?:evidence )?tool call|non[-\s]?TODO evidence tool|Do not call write_todos|Do not call write_todos or read_todos/i.test(text);
-    return (hasPriorPlanningToolResult(input) || hasNonPlanningEvidenceInstruction)
+    return (hasPriorPlanningToolResult(input) || readPromptedJsonToolPolicy(input) === "nonPlanningEvidence")
         && !hasPriorNonPlanningToolResult(input, boundTools);
 }
 function selectNonPlanningToolsForTurn(boundTools) {

package/dist/runtime/adapter/model/prompted-json-tool-policy.d.ts

@@ -0,0 +1,4 @@
+export declare const PROMPTED_JSON_TOOL_POLICY_KEY = "__agentHarnessPromptedJsonToolPolicy";
+export type PromptedJsonToolPolicy = "planning" | "nonPlanningEvidence";
+export declare function readPromptedJsonToolPolicy(input: unknown): PromptedJsonToolPolicy | undefined;
+export declare function withPromptedJsonToolPolicy<T>(input: T, policy: PromptedJsonToolPolicy): T;

package/dist/runtime/adapter/model/prompted-json-tool-policy.js

@@ -0,0 +1,22 @@
+export const PROMPTED_JSON_TOOL_POLICY_KEY = "__agentHarnessPromptedJsonToolPolicy";
+export function readPromptedJsonToolPolicy(input) {
+    if (typeof input !== "object" || input === null) {
+        return undefined;
+    }
+    const value = input[PROMPTED_JSON_TOOL_POLICY_KEY];
+    return value === "planning" || value === "nonPlanningEvidence" ? value : undefined;
+}
+export function withPromptedJsonToolPolicy(input, policy) {
+    if (typeof input !== "object" || input === null) {
+        return input;
+    }
+    if (Array.isArray(input)) {
+        return Object.assign([...input], {
+            [PROMPTED_JSON_TOOL_POLICY_KEY]: policy,
+        });
+    }
+    return {
+        ...input,
+        [PROMPTED_JSON_TOOL_POLICY_KEY]: policy,
+    };
+}

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

@@ -45,13 +45,13 @@ function buildDelegatedPlanEvidenceBlocker(agentId) {
         routing: [`delegated agent ${agentId}`],
         plan: ["delegate to specialist", "require visible TODO planning evidence", "return blocker when planning evidence is absent"],
         execution: [`task delegated to ${agentId}`, `delegated agent ${agentId} ended before producing required TODO plan evidence`],
-        todoTrace: ["TODO evidence missing"],
+        todoTrace: [`${agentId}: TODO evidence missing; delegated agent ended before producing required planning evidence.`],
         stepResults: ["delegated planning evidence was not observed"],
         summary: [`Delegated agent ${agentId} ended before producing the required TODO plan evidence.`],
         findings: ["The delegated run did not expose a valid planning trace, so the framework cannot treat the task as complete."],
         blockers: ["missing delegated TODO planning evidence"],
         nextActions: ["Retry with the same request or inspect the delegated agent configuration and model/tool-call behavior."],
-        report: `routing delegated to ${agentId}; todoTrace missing; stepResults blocked; summary missing planning evidence; findings require retry; blockers missing TODO planning evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
+        report: `routing delegated to ${agentId}; todoTrace ${agentId}: TODO evidence missing; stepResults blocked; summary missing planning evidence; findings require retry; blockers missing TODO planning evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
     });
 }
 function buildDelegatedExecutionEvidenceBlocker(agentId, expectedToolNames = []) {
@@ -65,7 +65,7 @@ function buildDelegatedExecutionEvidenceBlocker(agentId, expectedToolNames = [])
             `expected evidence tools: ${expectedTools}`,
             `delegated agent ${agentId} did not return any non-planning tool evidence after retry`,
         ],
-        todoTrace: ["TODO board observed without completed non-planning evidence"],
+        todoTrace: [`${agentId}: TODO evidence observed; delegated planning board did not produce completed non-planning evidence.`],
         stepResults: ["delegated execution evidence was not observed"],
         summary: [`Delegated agent ${agentId} did not return any non-planning tool evidence after retry.`],
         findings: [
@@ -75,7 +75,7 @@ function buildDelegatedExecutionEvidenceBlocker(agentId, expectedToolNames = [])
         ],
         blockers: ["missing delegated non-planning tool evidence"],
         nextActions: ["Retry the request or inspect the delegated agent's model/tool-call behavior."],
-        report: `routing delegated to ${agentId}; todoTrace observed planning only; stepResults blocked; summary missing non-planning tool evidence; findings expected evidence tools ${expectedTools}; blockers missing execution evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
+        report: `routing delegated to ${agentId}; todoTrace ${agentId}: TODO evidence observed but non-planning evidence missing; stepResults blocked; summary missing non-planning tool evidence; findings expected evidence tools ${expectedTools}; blockers missing execution evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
     });
 }
 function normalizePlanToolName(toolName) {
@@ -1562,8 +1562,8 @@ export class AgentRuntimeAdapter {
         const fallbackTodoTrace = [
             `1) TODO observed: delegated to ${delegatedSubagentType}.`,
             uniqueToolNames.some((toolName) => isPlanToolName(toolName))
-                ? "2) TODO evidence: delegated specialist invoked write_todos."
-                : "2) TODO evidence missing: delegated specialist did not expose write_todos in returned metadata.",
+                ? `2) ${delegatedSubagentType}: TODO evidence observed; delegated specialist invoked write_todos.`
+                : `2) ${delegatedSubagentType}: TODO evidence missing; delegated specialist did not expose write_todos in returned metadata.`,
             state === "failed"
                 ? "3) TODO closed: delegated execution failed; blocker reported."
                 : "3) TODO closed: delegated execution completed; synthesis returned.",

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

@@ -54,10 +54,7 @@ function inferPlanItemStatusFromTerminalAssistantOutput(value) {
     if (!normalized) {
         return null;
     }
-    if (normalized.startsWith("runtime_error=")
-        || /\bterminated\b/i.test(normalized)
-        || /\b(?:blocked|blocker|failed|failure|refused|unable to complete|could not complete)\b/i.test(normalized)
-        || /(?:执行失败|未能完成|无法完成|阻塞|失败)/u.test(normalized)) {
+    if (normalized.startsWith("runtime_error=")) {
         return "failed";
     }
     return isSubstantiveTerminalAssistantOutput(value) ? "completed" : null;
@@ -1065,7 +1062,7 @@ export async function* streamHarnessRun(options) {
         if (terminalAssistantPlanItemStatus === "failed"
             && sawSuccessfulToolResult
             && !explicitTerminalAssistantStatus
-            && !/^\s*terminated\b|\bBlockers?:\b|(?:委托执行失败|未能完成|无法完成)/iu.test(assistantOutput)
+            && !sanitizeVisibleText(assistantOutput).trim().toLowerCase().startsWith("runtime_error=")
             && assistantOutput.trim()) {
             terminalAssistantPlanItemStatus = "completed";
         }

package/package.json

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