@botbotgo/agent-harness 0.0.470 → 0.0.472

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.470";
+export declare const AGENT_HARNESS_VERSION = "0.0.472";
 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.470";
+export const AGENT_HARNESS_VERSION = "0.0.472";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/runtime/adapter/flow/invocation-flow.d.ts

@@ -16,16 +16,6 @@ export declare function executeRequestInvocation(options: {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
-        externalPlanEvidenceTool?: {
-            name: string;
-            args?: Record<string, unknown>;
-            id?: string;
-        };
-        externalPlanEvidenceTools?: Array<{
-            name: string;
-            args?: Record<string, unknown>;
-            id?: string;
-        }>;
     };
     resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
     getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;

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

@@ -329,8 +329,6 @@ export async function executeRequestInvocation(options) {
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
         toolRuntimeContext: invokeOptions.toolRuntimeContext,
         externalPlanEvidence: invokeOptions.externalPlanEvidence,
-        externalPlanEvidenceTool: invokeOptions.externalPlanEvidenceTool,
-        externalPlanEvidenceTools: invokeOptions.externalPlanEvidenceTools,
     });
     let localOrUpstreamInvocation = await invokeOnce(request);
     if (options.resumePayload === undefined

package/dist/runtime/adapter/flow/invoke-runtime.d.ts

@@ -18,16 +18,6 @@ export declare function invokeRuntimeWithLocalTools(options: {
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
     toolRuntimeContext?: Record<string, unknown>;
     externalPlanEvidence?: boolean;
-    externalPlanEvidenceTool?: {
-        name: string;
-        args?: Record<string, unknown>;
-        id?: string;
-    };
-    externalPlanEvidenceTools?: Array<{
-        name: string;
-        args?: Record<string, unknown>;
-        id?: string;
-    }>;
 }): Promise<{
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];

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

@@ -16,7 +16,5 @@ export async function invokeRuntimeWithLocalTools(options) {
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
         toolRuntimeContext: options.toolRuntimeContext,
         externalPlanEvidence: options.externalPlanEvidence,
-        externalPlanEvidenceTool: options.externalPlanEvidenceTool,
-        externalPlanEvidenceTools: options.externalPlanEvidenceTools,
     });
 }

package/dist/runtime/adapter/flow/stream-runtime.d.ts

@@ -23,16 +23,6 @@ export declare function streamRuntimeExecution(options: {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
-        externalPlanEvidenceTool?: {
-            name: string;
-            args?: Record<string, unknown>;
-            id?: string;
-        };
-        externalPlanEvidenceTools?: Array<{
-            name: string;
-            args?: Record<string, unknown>;
-            id?: string;
-        }>;
     };
     primaryTools: CompiledTool[];
     toolNameMapping: ToolNameMapping;
@@ -61,16 +51,6 @@ export declare function streamRuntimeExecution(options: {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
-        externalPlanEvidenceTool?: {
-            name: string;
-            args?: Record<string, unknown>;
-            id?: string;
-        };
-        externalPlanEvidenceTools?: Array<{
-            name: string;
-            args?: Record<string, unknown>;
-            id?: string;
-        }>;
     }) => Promise<{
         output: string;
         metadata?: Record<string, unknown>;

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

@@ -45,12 +45,6 @@ function buildRunEvidenceAfterPlanInstruction(primaryTools) {
         `Available non-planning tool names: ${toolNames.join(", ")}.`,
     ].join("\n");
 }
-function resolveSingleConfiguredPlanEvidenceTool(primaryTools) {
-    const toolNames = primaryTools
-        .map(readPrimaryToolName)
-        .filter((name) => name.length > 0 && !isPlanToolName(name));
-    return toolNames.length === 1 ? [{ name: toolNames[0], args: {}, id: "stream-single-plan-evidence-tool-1" }] : [];
-}
 const INITIAL_REQUIRED_PLAN_INSTRUCTION = [
     "This agent has a required visible planning contract.",
     "Your first action for this request must be write_todos with concrete task steps and statuses.",
@@ -721,7 +715,6 @@ export async function* streamRuntimeExecution(options) {
                     let sawCompletedPlanToolResult = false;
                     let sawSuccessfulNonTodoToolResult = false;
                     let earlyStreamRecoveryInstruction = null;
-                    let earlyStreamExternalPlanEvidenceTools;
                     let earlyStreamRecoverySuppressInitialPlan = false;
                     let completedPlanToolResultCount = 0;
                     for await (const event of options.iterateWithTimeout(events, options.streamIdleTimeoutMs, "agent streamEvents", options.streamDeadlineAt, options.invokeTimeoutMs)) {
@@ -751,7 +744,6 @@ export async function* streamRuntimeExecution(options) {
                             && hadPriorPlanToolResult
                             && projectedChunks.some((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName));
                         if (repeatedPlanToolResultBeforeEvidence) {
-                            earlyStreamExternalPlanEvidenceTools = resolveSingleConfiguredPlanEvidenceTool(options.primaryTools);
                             earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
@@ -797,7 +789,6 @@ export async function* streamRuntimeExecution(options) {
                             && (hadPriorPlanToolResult
                                 || projectedChunks.some((chunk) => isCompletedPlanToolResultChunk(chunk)))
                             && !sawSuccessfulNonTodoToolResult) {
-                            earlyStreamExternalPlanEvidenceTools = resolveSingleConfiguredPlanEvidenceTool(options.primaryTools);
                             earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
@@ -855,9 +846,6 @@ export async function* streamRuntimeExecution(options) {
                                         ?? terminalPrematurePlanCloseRecoveryInstruction
                                         ?? terminalDelegationOnlyRecoveryInstruction;
                                 earlyStreamRecoverySuppressInitialPlan = terminalPrematurePlanCloseRecoveryInstruction !== null;
-                                if (terminalPrematurePlanCloseRecoveryInstruction) {
-                                    earlyStreamExternalPlanEvidenceTools = resolveSingleConfiguredPlanEvidenceTool(options.primaryTools);
-                                }
                                 break;
                             }
                             if (requiresPlanEvidence(options.binding) && hasCompletedPlanWithEvidence(terminalExecutionEvidence)) {
@@ -892,9 +880,6 @@ export async function* streamRuntimeExecution(options) {
                             ? {
                                 ...withNonPlanningEvidenceToolPolicy(withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions)),
                                 externalPlanEvidence: true,
-                                ...(earlyStreamExternalPlanEvidenceTools && earlyStreamExternalPlanEvidenceTools.length > 0
-                                    ? { externalPlanEvidenceTools: earlyStreamExternalPlanEvidenceTools }
-                                    : {}),
                             }
                             : options.runtimeOptions;
                         const recovered = await options.invoke(options.applyToolRecoveryInstruction(options.binding, earlyStreamRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, earlyRecoveryRuntimeOptions);

package/dist/runtime/adapter/local-tool-invocation.d.ts

@@ -16,20 +16,10 @@ type LocalToolInvocationParams = {
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
     toolRuntimeContext?: Record<string, unknown>;
     externalPlanEvidence?: boolean;
-    externalPlanEvidenceTool?: {
-        name: string;
-        args?: Record<string, unknown>;
-        id?: string;
-    };
-    externalPlanEvidenceTools?: Array<{
-        name: string;
-        args?: Record<string, unknown>;
-        id?: string;
-    }>;
 };
 type LocalToolInvocationResult = {
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];
 };
-export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, externalPlanEvidence, externalPlanEvidenceTool, externalPlanEvidenceTools, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
+export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, externalPlanEvidence, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
 export {};

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

@@ -73,19 +73,6 @@ function buildBootstrapPlanToolResult(primaryTools) {
             })],
     };
 }
-function buildExternalPlanEvidenceToolResult(tools) {
-    return {
-        messages: [{
-                content: "",
-                tool_calls: tools.map((tool, index) => ({
-                    id: tool.id ?? `external-plan-evidence-${index + 1}-${Math.random().toString(36).slice(2, 10)}`,
-                    name: tool.name,
-                    args: tool.args ?? {},
-                    type: "tool_call",
-                })),
-            }],
-    };
-}
 function stripSatisfiedInitialPlanInstruction(messages) {
     return messages.filter((message) => {
         const typed = typeof message === "object" && message !== null ? message : {};
@@ -204,6 +191,78 @@ function buildDeterministicFinalFromToolEvidence(executedToolResults) {
 function hasPlanStateEvidence(executedToolResults, externalPlanEvidence = false) {
     return externalPlanEvidence || executedToolResults.some((item) => isPlanToolName(item.toolName) || readPlanStateSummary(item.output) !== null);
 }
+function isNonFunctionObject(value) {
+    return Object(value) === value && typeof value !== "function";
+}
+function readSerializedMessageType(value) {
+    if (!isNonFunctionObject(value)) {
+        return "";
+    }
+    const id = value.id;
+    if (!Array.isArray(id)) {
+        return "";
+    }
+    return id.map((item) => typeof item === "string" ? item : "").filter(Boolean).join(".");
+}
+function readUpstreamToolMessage(value) {
+    if (!isNonFunctionObject(value)) {
+        return null;
+    }
+    const typed = value;
+    const kwargs = isNonFunctionObject(typed.kwargs) ? typed.kwargs : {};
+    const lcKwargs = isNonFunctionObject(typed.lc_kwargs) ? typed.lc_kwargs : {};
+    const messageType = readSerializedMessageType(value);
+    const isToolMessage = typed.role === "tool"
+        || typed.type === "tool"
+        || messageType.endsWith("ToolMessage")
+        || typeof typed.tool_call_id === "string"
+        || typeof kwargs.tool_call_id === "string"
+        || typeof lcKwargs.tool_call_id === "string";
+    if (!isToolMessage) {
+        return null;
+    }
+    const toolNameCandidate = kwargs.name ?? lcKwargs.name ?? typed.name;
+    const toolName = typeof toolNameCandidate === "string" ? toolNameCandidate.trim() : "";
+    if (!toolName) {
+        return null;
+    }
+    const output = kwargs.content ?? lcKwargs.content ?? typed.content ?? "";
+    const status = kwargs.status ?? lcKwargs.status ?? typed.status;
+    return {
+        toolName,
+        output,
+        ...(status === "error" ? { isError: true } : {}),
+    };
+}
+function extractUpstreamToolMessages(value, seen = new Set()) {
+    if (typeof value !== "object" || value === null || seen.has(value)) {
+        return [];
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => extractUpstreamToolMessages(item, seen));
+    }
+    const direct = readUpstreamToolMessage(value);
+    if (direct) {
+        return [direct];
+    }
+    const typed = value;
+    return [
+        ...extractUpstreamToolMessages(typed.messages, seen),
+        ...extractUpstreamToolMessages(typed.output, seen),
+    ];
+}
+function mergeUpstreamToolMessages(executedToolResults, result) {
+    const existing = new Set(executedToolResults.map((item) => `${item.toolName}\u0000${item.isError === true ? "error" : "ok"}\u0000${stringifyToolOutput(item.output)}`));
+    for (const upstream of extractUpstreamToolMessages(result)) {
+        const key = `${upstream.toolName}\u0000${upstream.isError === true ? "error" : "ok"}\u0000${stringifyToolOutput(upstream.output)}`;
+        if (existing.has(key)) {
+            continue;
+        }
+        existing.add(key);
+        executedToolResults.push(upstream);
+    }
+}
 function latestToolErrorRecoveryInstruction(executedToolResults) {
     const latest = executedToolResults.at(-1);
     if (!latest || latest.isError !== true) {
@@ -285,7 +344,7 @@ function summarizeResultMessages(result) {
         };
     });
 }
-export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, externalPlanEvidence, externalPlanEvidenceTool, externalPlanEvidenceTools, }) {
+export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, externalPlanEvidence, }) {
     const executedToolResults = [];
     let activeRequest = request;
     let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
@@ -307,39 +366,11 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
     }
     for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
         const isFinalIteration = iteration + 1 === maxToolIterations;
-        const externalPlanEvidenceToolCalls = externalPlanEvidenceTools && externalPlanEvidenceTools.length > 0
-            ? externalPlanEvidenceTools
-            : externalPlanEvidenceTool
-                ? [externalPlanEvidenceTool]
-                : [];
-        const shouldRunExternalPlanEvidenceTool = pendingResult === undefined
-            && requiresPlanEvidence(binding)
-            && externalPlanEvidence === true
-            && externalPlanEvidenceToolCalls.length > 0
-            && !hasNonTodoToolEvidence(executedToolResults);
-        const usedExternalPlanEvidenceToolThisIteration = shouldRunExternalPlanEvidenceTool;
         result = pendingResult
-            ?? (shouldRunExternalPlanEvidenceTool
-                ? buildExternalPlanEvidenceToolResult(externalPlanEvidenceToolCalls)
-                : await callRuntimeWithToolParseRecovery(activeRequest));
+            ?? await callRuntimeWithToolParseRecovery(activeRequest);
         pendingResult = undefined;
+        mergeUpstreamToolMessages(executedToolResults, result);
         let toolCalls = extractToolCallsFromResult(result);
-        const structuredExternalPlanEvidenceTool = requiresPlanEvidence(binding)
-            && hasPlanStateEvidence(executedToolResults, externalPlanEvidence)
-            && !hasNonTodoToolEvidence(executedToolResults)
-            && (externalPlanEvidenceTool !== undefined || !hasIncompleteExecutedPlan(executedToolResults, externalPlanEvidence))
-            && (toolCalls.length === 0 || toolCalls.every((toolCall) => isPlanToolName(toolCall.name)))
-            ? externalPlanEvidenceTool
-                ? {
-                    name: externalPlanEvidenceTool.name,
-                    args: externalPlanEvidenceTool.args ?? {},
-                    id: externalPlanEvidenceTool.id ?? "external-plan-evidence-tool",
-                }
-                : null
-            : null;
-        if (structuredExternalPlanEvidenceTool) {
-            toolCalls = [structuredExternalPlanEvidenceTool];
-        }
         if (toolCalls.length === 0) {
             const terminalText = sanitizeVisibleText(extractVisibleOutput(result) || "");
             const hasIncompletePlanState = hasIncompleteExecutedPlan(executedToolResults, externalPlanEvidence);
@@ -496,8 +527,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
         repeatedRecoveryWithoutProgress = 0;
         repeatedPlanOnlyAfterPlan = 0;
         repeatedInvalidExternalPlanEvidenceSelection = 0;
-        const canReplayToolCalls = usedExternalPlanEvidenceToolThisIteration
-            || canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools);
+        const canReplayToolCalls = canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools);
         debugLocalToolReplay({
             toolCalls,
             result,
@@ -583,12 +613,6 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 content: stringifyToolOutput(safeToolResult),
             }));
         }
-        if (usedExternalPlanEvidenceToolThisIteration && hasNonTodoToolEvidence(executedToolResults)) {
-            return {
-                result: buildDeterministicFinalFromToolEvidence(executedToolResults),
-                executedToolResults,
-            };
-        }
         if (requiresPlanEvidence(binding)
             && toolCalls.length > 0
             && toolCalls.every((toolCall) => isPlanToolName(toolCall.name))

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -1,5 +1,5 @@
 import { salvageToolArgs } from "../../parsing/output-parsing.js";
-import { normalizeKnownToolArgs, salvageJsonToolCalls, salvageResultLabeledToolCall } from "../../parsing/output-tool-args.js";
+import { normalizeKnownToolArgs, salvageJsonToolCalls, salvageMarkdownNamedToolCall, salvageResultLabeledToolCall } from "../../parsing/output-tool-args.js";
 import { isRecord } from "../../../utils/object.js";
 import { extractExplicitResourceReferences, hasExplicitResourceReference } from "../../harness/system/runtime-memory-policy.js";
 import { readCapturedPromptedJsonToolCalls } from "../model/prompted-json-tool-call-capture.js";
@@ -463,6 +463,15 @@ export function extractToolCallsFromResult(result) {
                     rawArgsInput: content,
                 }];
         }
+        const markdownNamedToolCall = salvageMarkdownNamedToolCall(content);
+        if (markdownNamedToolCall) {
+            return [{
+                    id: "salvaged-markdown-label-1",
+                    name: markdownNamedToolCall.name,
+                    args: markdownNamedToolCall.args,
+                    rawArgsInput: content,
+                }];
+        }
         const salvaged = salvageJsonToolCalls(content);
         if (salvaged.length > 0) {
             return salvaged.map((toolCall, salvageIndex) => ({

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

@@ -62,11 +62,6 @@ export declare class AgentRuntimeAdapter {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
-        externalPlanEvidenceTools?: Array<{
-            name: string;
-            args?: Record<string, unknown>;
-            id?: string;
-        }>;
     }): Promise<RequestResult>;
     private tryDelegateWithCompactRouter;
     private buildCompactDelegationReport;
@@ -82,11 +77,6 @@ export declare class AgentRuntimeAdapter {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
-        externalPlanEvidenceTools?: Array<{
-            name: string;
-            args?: Record<string, unknown>;
-            id?: string;
-        }>;
     }): AsyncGenerator<RuntimeStreamChunk | string>;
 }
 export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };

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

@@ -10,7 +10,6 @@ import { resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths,
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { PROMPTED_JSON_TOOL_POLICY_KEY } from "./adapter/model/prompted-json-tool-policy.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
-import { extractExplicitResourceReferences } from "./harness/system/runtime-memory-policy.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { resolveDeterministicFinalOutput } from "./adapter/invocation-result.js";
 import { applyToolRecoveryInstruction as applyToolRecoveryInstructionHelper, applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
@@ -442,73 +441,17 @@ const DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION = [
     "The next runtime event must be one available non-planning evidence tool call.",
     "After that tool returns, update or close the TODO board and provide the final answer required by the agent response format.",
 ].join("\n");
-function buildDelegatedPlanEvidenceRecoveryOptions(binding, baseOptions, requestText = "") {
-    const nonPlanningTools = binding
-        ? getBindingPrimaryTools(binding).filter((tool) => !isPlanToolName(tool.name))
-        : [];
-    const configuredRecoveryTool = resolveConfiguredRecoveryEvidenceTool(binding, nonPlanningTools, requestText);
-    const externalPlanEvidenceTools = configuredRecoveryTool
-        ? [configuredRecoveryTool]
-        : nonPlanningTools.length === 1
-            ? [{
-                    name: nonPlanningTools[0].name,
-                    args: buildExternalPlanEvidenceArgs(nonPlanningTools[0], requestText),
-                    id: "delegated-plan-evidence-tool-1",
-                }]
-            : undefined;
+function buildDelegatedPlanEvidenceRecoveryOptions(_binding, baseOptions, _requestText = "") {
     return {
         ...baseOptions,
         suppressInitialRequiredPlanInstruction: true,
         externalPlanEvidence: true,
-        ...(externalPlanEvidenceTools ? { externalPlanEvidenceTools } : {}),
         state: {
             ...(typeof baseOptions.state === "object" && baseOptions.state !== null ? baseOptions.state : {}),
             [PROMPTED_JSON_TOOL_POLICY_KEY]: "nonPlanningEvidence",
         },
     };
 }
-function resolveConfiguredRecoveryEvidenceTool(binding, nonPlanningTools, requestText) {
-    const configured = binding?.harnessRuntime.executionContract?.recoveryEvidenceTool;
-    const configuredName = typeof configured?.name === "string" ? configured.name.trim() : "";
-    if (!configuredName) {
-        return undefined;
-    }
-    const tool = nonPlanningTools.find((candidate) => candidate.name === configuredName);
-    if (!tool) {
-        return undefined;
-    }
-    return {
-        name: tool.name,
-        args: configured?.args ?? buildExternalPlanEvidenceArgs(tool, requestText),
-        id: "delegated-plan-evidence-tool-1",
-    };
-}
-function buildExternalPlanEvidenceArgs(tool, requestText) {
-    const properties = tool?.modelSchema && typeof tool.modelSchema === "object"
-        && tool.modelSchema !== null
-        && typeof tool.modelSchema.properties === "object"
-        && tool.modelSchema.properties !== null
-        ? tool.modelSchema.properties
-        : {};
-    const refs = extractExplicitResourceReferences(requestText);
-    const args = {};
-    const firstUrl = refs.find((ref) => /^https?:\/\//iu.test(ref));
-    if ("url" in properties && firstUrl) {
-        args.url = firstUrl;
-    }
-    if ("sources" in properties && refs.length > 0) {
-        args.sources = refs.map((ref) => /^https?:\/\//iu.test(ref)
-            ? { type: "url", url: ref }
-            : { type: "text", text: ref });
-    }
-    if ("question" in properties) {
-        args.question = requestText;
-    }
-    else if ("query" in properties) {
-        args.query = requestText;
-    }
-    return args;
-}
 function looksLikeRawCommandTranscript(value) {
     const normalized = value.trim();
     return /^(?:stdout|stderr)\s*:/iu.test(normalized)
@@ -1984,7 +1927,6 @@ export class AgentRuntimeAdapter {
                         profiling: options.profiling,
                         suppressInitialRequiredPlanInstruction: delegatedOptions.suppressInitialRequiredPlanInstruction,
                         externalPlanEvidence: delegatedOptions.externalPlanEvidence,
-                        externalPlanEvidenceTools: delegatedOptions.externalPlanEvidenceTools,
                     })) {
                         if (typeof chunk === "string") {
                             output += chunk;
@@ -2209,7 +2151,6 @@ export class AgentRuntimeAdapter {
                     profiling: options.profiling,
                     suppressInitialRequiredPlanInstruction: delegatedOptions.suppressInitialRequiredPlanInstruction,
                     externalPlanEvidence: delegatedOptions.externalPlanEvidence,
-                    externalPlanEvidenceTools: delegatedOptions.externalPlanEvidenceTools,
                 })) {
                     if (typeof chunk === "string") {
                         output += chunk;

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

@@ -11,6 +11,10 @@ export declare function salvageResultLabeledToolCall(value: unknown): {
     name: string;
     args: Record<string, unknown>;
 } | null;
+export declare function salvageMarkdownNamedToolCall(value: unknown): {
+    name: string;
+    args: Record<string, unknown>;
+} | null;
 export declare function salvageToolArgs(value: unknown): Record<string, unknown> | null;
 export declare function salvageJsonToolCalls(value: unknown): Array<{
     name: string;

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

@@ -195,6 +195,28 @@ export function salvageResultLabeledToolCall(value) {
     const args = salvageToolArgs(lines.slice(1).join("\n")) ?? {};
     return { name: match[1], args: normalizeKnownToolArgs(match[1], args) };
 }
+export function salvageMarkdownNamedToolCall(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const lines = value
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length < 2) {
+        return null;
+    }
+    const label = lines[0]?.replace(/[*`#]/gu, "").trim() ?? "";
+    if (!isToolName(label) || ["json", "javascript", "typescript", "python", "yaml", "text"].includes(label.toLowerCase())) {
+        return null;
+    }
+    const rest = lines.slice(1).join("\n").trim();
+    const args = salvageToolArgs(rest);
+    if (!args) {
+        return null;
+    }
+    return { name: label, args: normalizeKnownToolArgs(label, args) };
+}
 function extractBalancedJsonValue(value, openChar, closeChar) {
     const start = value.indexOf(openChar);
     if (start < 0)

package/package.json

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

package/dist/resources/prompts/runtime/write-todos-descriptive-content.md

@@ -1 +0,0 @@
-When first calling write_todos, use descriptive task content for each todo item. Do not use placeholders like '1', '2', '3', 'step 1', or 'todo 1'. Describe the real step, for example 'Create tmp-counter.txt' or 'Append digit 2 and read the file'.