@botbotgo/agent-harness 0.0.440 → 0.0.442

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.440";
+export declare const AGENT_HARNESS_VERSION = "0.0.442";
 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.440";
+export const AGENT_HARNESS_VERSION = "0.0.442";
 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/invocation-request.js

@@ -125,42 +125,6 @@ function buildContextualFollowUpInstruction(inputText, hasDurableMemory) {
     }
     return "Answer the user's current follow-up directly from the recalled context when it remains relevant. If recalled memory conflicts with the current system prompt, runtime policy, recovery instruction, available tool evidence, or the user's current request, ignore the recalled memory for this turn. If the current user turn corrects, revokes, deletes, or replaces recalled memory, treat the user's latest statement as newer than the recalled memory for this turn. Do not frame the reply as a fresh URL or page summary unless the current user turn explicitly includes a new resource to inspect.";
 }
-function isIncidentFollowUpTurn(inputText) {
-    const normalized = inputText.trim().toLowerCase();
-    if (!normalized || hasExplicitResourceReference(normalized)) {
-        return false;
-    }
-    return /(the rca|deep research.*rca|root cause|go deeper|those issues|these issues|that issue|current incident)/i.test(normalized);
-}
-function findLastAssistantText(history) {
-    for (let index = history.length - 1; index >= 0; index -= 1) {
-        const message = history[index];
-        if (message?.role !== "assistant") {
-            continue;
-        }
-        const text = extractMessageText(message.content).trim();
-        if (text) {
-            return compactHistoryText(text);
-        }
-    }
-    return undefined;
-}
-function buildIncidentFollowUpInstruction(history, inputText) {
-    if (!isIncidentFollowUpTurn(inputText)) {
-        return undefined;
-    }
-    const priorAssistantText = findLastAssistantText(history);
-    if (!priorAssistantText) {
-        return undefined;
-    }
-    return [
-        "Treat the user's current turn as a follow-up on the current incident, not as a generic background-knowledge request.",
-        "Use the immediately prior assistant findings below as the default incident context unless the user explicitly overrides it.",
-        "",
-        "Prior assistant findings:",
-        priorAssistantText,
-    ].join("\n");
-}
 export function buildSlashCommandSkillInstruction(binding, input) {
     const inputText = extractMessageText(input).trim();
     const match = inputText.match(/^\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?$/i);
@@ -198,7 +162,6 @@ export function buildInvocationRequest(binding, history, input, options = {}) {
         suppressHistoryTurns: Boolean(memoryInstruction) && !hasExplicitResourceReference(inputText),
     });
     const contextualFollowUpInstruction = buildContextualFollowUpInstruction(inputText, Boolean(memoryInstruction));
-    const incidentFollowUpInstruction = buildIncidentFollowUpInstruction(history, inputText);
     const conversationLanguage = resolveConversationLanguage(history, inputText);
     const languageInstruction = !inferMessageLanguage(inputText) && conversationLanguage
         ? {
@@ -212,7 +175,6 @@ export function buildInvocationRequest(binding, history, input, options = {}) {
         messages: [
             ...(memoryInstruction ? [{ role: "system", content: memoryInstruction }] : []),
             ...(contextualFollowUpInstruction ? [{ role: "system", content: contextualFollowUpInstruction }] : []),
-            ...(incidentFollowUpInstruction ? [{ role: "system", content: incidentFollowUpInstruction }] : []),
             ...(languageInstruction ? [{ role: "system", content: languageInstruction }] : []),
             ...(userInvocableInstruction ? [{ role: "system", content: userInvocableInstruction }] : []),
             ...messages,

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/package.json

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