@botbotgo/agent-harness 0.0.330 → 0.0.333

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.329";
-export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-23";
+export declare const AGENT_HARNESS_VERSION = "0.0.332";
+export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-22";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.329";
-export const AGENT_HARNESS_RELEASE_DATE = "2026-04-23";
+export const AGENT_HARNESS_VERSION = "0.0.332";
+export const AGENT_HARNESS_RELEASE_DATE = "2026-04-22";

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

@@ -148,7 +148,14 @@ export async function* streamRuntimeExecution(options) {
     const shouldDeferStreamContent = () => shouldValidateStreamOutput && !emittedUnsafeStreamSideEffects;
     const flushDeferredStreamContent = async function* () {
         while (deferredStreamContent.length > 0) {
-            yield deferredStreamContent.shift();
+            const next = deferredStreamContent.shift();
+            if (next.kind === "content") {
+                if (next.content) {
+                    yield { kind: "content", content: next.content };
+                }
+                continue;
+            }
+            yield next;
         }
     };
     try {

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

@@ -5,6 +5,13 @@ export type ExecutedToolResult = {
     isError?: boolean;
     memoryCandidates?: MemoryCandidate[];
 };
+export declare function resolveDeterministicFinalOutput(params: {
+    visibleOutput?: string;
+    toolFallback?: string;
+    executedToolResults?: ExecutedToolResult[];
+}): string;
+export declare function extractDelegatedFindingsText(executedToolResults: ExecutedToolResult[]): string;
+export declare function extractToolResultFindingsText(executedToolResults: ExecutedToolResult[]): string;
 export declare function finalizeRequestResult(params: {
     bindingAgentId: string;
     sessionId: string;

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

@@ -1,6 +1,95 @@
 import { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, sanitizeVisibleText, tryParseJson, } from "../parsing/output-parsing.js";
+import { salvageFunctionLikeToolCall } from "../parsing/output-tool-args.js";
 import { buildStateSnapshot } from "./model/message-assembly.js";
 import { asRecord } from "./tool/resolved-tool.js";
+function looksLikeLeakedToolCallText(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (!normalized) {
+        return false;
+    }
+    if (salvageFunctionLikeToolCall(normalized)) {
+        return true;
+    }
+    const prefixedToolCallMatch = /^(?:\s*(?:Ready|Understood|Okay|Ok|Got it|Sure|All set|What is your request|Please provide a task for me to orchestrate)[.:?!]?\s*)+([A-Za-z_][A-Za-z0-9_]*\([\s\S]*\))\s*$/u.exec(normalized);
+    return !!(prefixedToolCallMatch && salvageFunctionLikeToolCall(prefixedToolCallMatch[1]));
+}
+function isPlaceholderTaskCompletion(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    return normalized === "Task completed";
+}
+function normalizeToolOutputText(output) {
+    const directText = typeof output === "string"
+        ? sanitizeVisibleText(output).trim()
+        : "";
+    if (directText && !looksLikeLeakedToolCallText(directText) && !isPlaceholderTaskCompletion(directText)) {
+        return directText;
+    }
+    const visibleOutput = sanitizeVisibleText(extractVisibleOutput(output)).trim();
+    if (visibleOutput && !looksLikeLeakedToolCallText(visibleOutput) && !isPlaceholderTaskCompletion(visibleOutput)) {
+        return visibleOutput;
+    }
+    const fallbackContext = sanitizeVisibleText(extractToolFallbackContext(output)).trim();
+    if (fallbackContext && !looksLikeLeakedToolCallText(fallbackContext) && !isPlaceholderTaskCompletion(fallbackContext)) {
+        return fallbackContext;
+    }
+    return "";
+}
+function extractLatestSuccessfulTaskResultText(executedToolResults) {
+    for (const toolResult of [...executedToolResults].reverse()) {
+        if (toolResult.isError === true || toolResult.toolName !== "task") {
+            continue;
+        }
+        const normalized = normalizeToolOutputText(toolResult.output);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return "";
+}
+function extractLatestSuccessfulNonTodoToolResultText(executedToolResults) {
+    for (const toolResult of [...executedToolResults].reverse()) {
+        if (toolResult.isError === true) {
+            continue;
+        }
+        if (toolResult.toolName === "task" || toolResult.toolName === "write_todos" || toolResult.toolName === "read_todos") {
+            continue;
+        }
+        const normalized = normalizeToolOutputText(toolResult.output);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return "";
+}
+export function resolveDeterministicFinalOutput(params) {
+    const visibleOutput = params.visibleOutput ?? "";
+    const toolFallback = params.toolFallback ?? "";
+    const executedToolResults = params.executedToolResults ?? [];
+    const delegatedTaskOutput = extractLatestSuccessfulTaskResultText(executedToolResults);
+    if (delegatedTaskOutput) {
+        return delegatedTaskOutput;
+    }
+    const sanitizedVisibleOutput = visibleOutput && !looksLikeLeakedToolCallText(visibleOutput)
+        ? sanitizeVisibleText(visibleOutput).trim()
+        : "";
+    if (sanitizedVisibleOutput) {
+        return sanitizedVisibleOutput;
+    }
+    const successfulToolOutput = extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
+    if (successfulToolOutput) {
+        return successfulToolOutput;
+    }
+    const sanitizedToolFallback = toolFallback && !looksLikeLeakedToolCallText(toolFallback)
+        ? sanitizeVisibleText(toolFallback).trim()
+        : "";
+    return sanitizedToolFallback;
+}
+export function extractDelegatedFindingsText(executedToolResults) {
+    return extractLatestSuccessfulTaskResultText(executedToolResults);
+}
+export function extractToolResultFindingsText(executedToolResults) {
+    return extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
+}
 export function finalizeRequestResult(params) {
     const { bindingAgentId, sessionId, requestId, result, executedToolResults } = params;
     const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
@@ -12,7 +101,12 @@ export function finalizeRequestResult(params) {
         throw new Error(emptyAssistantMessageFailure);
     }
     const serializedResult = JSON.stringify(result, null, 2);
-    const output = visibleOutput || toolFallback || (containsLikelySkillDocument(result) ? "" : serializedResult);
+    const output = resolveDeterministicFinalOutput({
+        visibleOutput,
+        toolFallback,
+        executedToolResults,
+    })
+        || (containsLikelySkillDocument(result) ? "" : serializedResult);
     const finalMessageText = sanitizeVisibleText(output);
     const outputContent = extractOutputContent(result);
     const contentBlocks = extractContentBlocks(result);

package/dist/runtime/adapter/middleware-assembly.js

@@ -12,6 +12,7 @@ import { materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.
 import { DEFAULT_SUBAGENT_PROMPT } from "../prompts/runtime-prompts.js";
 import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION } from "../prompts/runtime-prompts.js";
 import { createStreamEventProjectionState, projectRuntimeStreamEvent } from "./stream-event-projection.js";
+import { resolveDeterministicFinalOutput } from "./invocation-result.js";
 const EMPTY_TOOL_NAME_MAPPING = {
     originalToModelFacing: new Map(),
     modelFacingToOriginal: new Map(),
@@ -268,9 +269,10 @@ export async function invokeBuiltinTaskTool(input) {
     if (typeof runnable.streamEvents === "function") {
         const runWithStreamInspection = async (recoveryInstruction) => {
             const projectionState = createStreamEventProjectionState();
+            const executedToolResults = [];
             const events = await runnable.streamEvents(buildMessages(recoveryInstruction), invokeConfig);
             for await (const event of events) {
-                projectRuntimeStreamEvent({
+                const projectedChunks = projectRuntimeStreamEvent({
                     event,
                     allowVisibleStreamDeltas: false,
                     includeStateStreamOutput: false,
@@ -280,15 +282,25 @@ export async function invokeBuiltinTaskTool(input) {
                     primaryTools: [],
                     state: projectionState,
                 });
+                for (const chunk of projectedChunks) {
+                    if (chunk.kind !== "tool-result") {
+                        continue;
+                    }
+                    executedToolResults.push({
+                        toolName: chunk.toolName,
+                        output: chunk.output,
+                        isError: chunk.isError,
+                    });
+                }
             }
-            return projectionState;
+            return { projectionState, executedToolResults };
         };
-        let projectionState = await runWithStreamInspection();
+        let { projectionState, executedToolResults } = await runWithStreamInspection();
         if (requiresDelegatedExecutionRecovery(projectionState)) {
             const recoveryInstruction = projectionState.hasIncompletePlanState && projectionState.emittedToolError
                 ? `${AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION}\n\n${DELEGATED_FAILURE_PLAN_RECONCILIATION_INSTRUCTION}`
                 : AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION;
-            projectionState = await runWithStreamInspection(recoveryInstruction);
+            ({ projectionState, executedToolResults } = await runWithStreamInspection(recoveryInstruction));
         }
         if (requiresDelegatedExecutionRecovery(projectionState)) {
             throw new Error(formatDelegatedExecutionBlocker(projectionState));
@@ -297,14 +309,20 @@ export async function invokeBuiltinTaskTool(input) {
             throw new Error("Delegated investigation ended without any real tool execution evidence.");
         }
         if (projectionState.emittedToolError) {
-            const blockerMessage = projectionState.emittedOutput.trim()
-                || formatDelegatedExecutionBlocker(projectionState);
+            const blockerMessage = resolveDeterministicFinalOutput({
+                visibleOutput: projectionState.emittedOutput.trim(),
+                executedToolResults,
+            }) || formatDelegatedExecutionBlocker(projectionState);
             if (hasUnresolvedDelegatedExecution(projectionState) || !projectionState.emittedSuccessfulToolResult) {
                 throw new Error(blockerMessage);
             }
         }
-        if (projectionState.emittedOutput.trim()) {
-            return projectionState.emittedOutput.trim();
+        const deterministicOutput = resolveDeterministicFinalOutput({
+            visibleOutput: projectionState.emittedOutput.trim(),
+            executedToolResults,
+        });
+        if (deterministicOutput) {
+            return deterministicOutput;
         }
         if (projectionState.emittedToolResult) {
             throw new Error("Delegated investigation performed tool work but did not return surfaced findings.");

package/dist/runtime/adapter/stream-event-projection.js

@@ -1,4 +1,5 @@
 import { sanitizeVisibleText } from "../parsing/output-parsing.js";
+import { salvageFunctionLikeToolCall } from "../parsing/output-tool-args.js";
 import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, sanitizeRetainedUpstreamEvent, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, } from "../parsing/stream-event-parsing.js";
 import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
 export function createStreamEventProjectionState() {
@@ -24,6 +25,20 @@ export function createStreamEventProjectionState() {
         seenTerminalOutputs: new Set(),
     };
 }
+function shouldSuppressVisibleToolCallText(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (salvageFunctionLikeToolCall(trimmed)) {
+        return true;
+    }
+    const prefixedToolCallMatch = /^(?:\s*(?:Ready|Understood|Okay|Ok|Got it|Sure|All set)[.:!]?\s*)+([A-Za-z_][A-Za-z0-9_]*\([\s\S]*\))\s*$/u.exec(trimmed);
+    if (!prefixedToolCallMatch) {
+        return false;
+    }
+    return salvageFunctionLikeToolCall(prefixedToolCallMatch[1]) !== null;
+}
 function readSummaryCounts(summary) {
     if (typeof summary !== "object" || summary === null) {
         return null;
@@ -218,7 +233,7 @@ export function projectRuntimeStreamEvent(params) {
     const allowStreamedVisibleContent = allowVisibleContent && !state.emittedToolResult && !state.emittedToolError;
     if (allowVisibleStreamDeltas && allowStreamedVisibleContent) {
         const visibleStreamOutput = extractVisibleStreamOutput(event);
-        if (visibleStreamOutput) {
+        if (visibleStreamOutput && !shouldSuppressVisibleToolCallText(visibleStreamOutput)) {
             const nextOutput = computeIncrementalOutput(state.emittedOutput, visibleStreamOutput);
             state.emittedOutput = nextOutput.accumulated;
             if (nextOutput.delta) {
@@ -228,8 +243,8 @@ export function projectRuntimeStreamEvent(params) {
     }
     if (includeStateStreamOutput && allowVisibleContent) {
         const stateStreamOutput = extractStateStreamOutput(event);
-        if (stateStreamOutput) {
-            const nextOutput = computeIncrementalOutput(state.emittedOutput, sanitizeVisibleText(stateStreamOutput));
+        if (stateStreamOutput && !shouldSuppressVisibleToolCallText(stateStreamOutput)) {
+            const nextOutput = computeIncrementalOutput(state.emittedOutput, stateStreamOutput);
             state.emittedOutput = nextOutput.accumulated;
             if (nextOutput.delta) {
                 chunks.push({ kind: "content", content: nextOutput.delta });
@@ -269,7 +284,7 @@ export function projectRuntimeStreamEvent(params) {
             state.emittedDelegatedTerminalOutput = true;
         }
     }
-    if (output) {
+    if (output && !shouldSuppressVisibleToolCallText(output)) {
         const outputKey = normalizeTerminalOutputKey(output);
         if (!outputKey || !state.seenTerminalOutputs.has(outputKey)) {
             if (outputKey) {

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

@@ -1,6 +1,8 @@
+import { resolveDeterministicFinalOutput, } from "../../adapter/invocation-result.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from "../../agent-runtime-adapter.js";
 import { ExecutionReconciliationError } from "../../adapter/flow/stream-runtime.js";
 import { buildRequestPlanState, summarizeBuiltinWriteTodosArgs } from "../../adapter/runtime-adapter-support.js";
+import { sanitizeVisibleText } from "../../parsing/output-parsing.js";
 import { describeRuntimeError, renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
 import { createContentBlocksItem, createToolResultKey, } from "../events/streaming.js";
@@ -466,7 +468,9 @@ export async function* streamHarnessRun(options) {
         ]).then(([loadedPriorHistory, resolvedReleaseRunSlot]) => [loadedPriorHistory, resolvedReleaseRunSlot]);
         releaseRunSlot = acquiredReleaseRunSlot;
         const toolErrors = [];
+        let sawSuccessfulToolResult = false;
         let lastToolResultKey = null;
+        const executedToolResults = [];
         const recalledMemories = options.invocation.memoryRecall?.items ?? [];
         for (const item of createRuntimeMemoryRecallSteps(options.sessionId, options.requestId, recalledMemories)) {
             yield item;
@@ -637,9 +641,17 @@ export async function* streamHarnessRun(options) {
                     continue;
                 }
                 lastToolResultKey = toolResultKey;
+                executedToolResults.push({
+                    toolName: normalizedChunk.toolName,
+                    output: normalizedChunk.output,
+                    isError: normalizedChunk.isError,
+                });
                 if (normalizedChunk.isError) {
                     toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
                 }
+                else {
+                    sawSuccessfulToolResult = true;
+                }
                 yield {
                     type: "tool-result",
                     sessionId: options.sessionId,
@@ -714,10 +726,18 @@ export async function* streamHarnessRun(options) {
                 content: normalizedChunk.content,
             };
         }
-        if (!assistantOutput && toolErrors.length > 0) {
+        if (!assistantOutput && toolErrors.length > 0 && !sawSuccessfulToolResult) {
             assistantOutput = toolErrors.join("\n\n");
             emitted = true;
         }
+        const resolvedAssistantOutput = resolveDeterministicFinalOutput({
+            visibleOutput: assistantOutput,
+            executedToolResults,
+        });
+        if (sanitizeVisibleText(resolvedAssistantOutput) !== sanitizeVisibleText(assistantOutput)) {
+            assistantOutput = resolvedAssistantOutput;
+            emitted = emitted || assistantOutput.length > 0;
+        }
         currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
         if (!assistantOutput) {
             const actual = await options.invokeWithHistory(options.binding, options.input, options.sessionId, options.requestId);

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

@@ -1,11 +1,93 @@
 import { AIMessage } from "langchain";
 import { salvageFunctionLikeToolCall, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
+function consumeLeadingFunctionLikeToolCall(value) {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\(/.exec(value);
+    if (!match) {
+        return null;
+    }
+    let depthParen = 0;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let inString = false;
+    let quoteChar = "";
+    let escaping = false;
+    for (let index = match[0].length - 1; index < value.length; index += 1) {
+        const char = value[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaping = true;
+                continue;
+            }
+            if (char === quoteChar) {
+                inString = false;
+                quoteChar = "";
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            inString = true;
+            quoteChar = char;
+            continue;
+        }
+        if (char === "(") {
+            depthParen += 1;
+            continue;
+        }
+        if (char === ")") {
+            depthParen -= 1;
+            if (depthParen === 0 && depthBracket === 0 && depthBrace === 0) {
+                const candidate = value.slice(0, index + 1);
+                return salvageFunctionLikeToolCall(candidate) ? candidate : null;
+            }
+            continue;
+        }
+        if (char === "[")
+            depthBracket += 1;
+        else if (char === "]")
+            depthBracket -= 1;
+        else if (char === "{")
+            depthBrace += 1;
+        else if (char === "}")
+            depthBrace -= 1;
+    }
+    return null;
+}
+function stripVisibleFunctionLikeToolCallText(value) {
+    let remaining = value.trim();
+    let removedLeadingCall = false;
+    while (remaining.length > 0) {
+        const consumed = consumeLeadingFunctionLikeToolCall(remaining);
+        if (!consumed) {
+            break;
+        }
+        removedLeadingCall = true;
+        remaining = remaining.slice(consumed.length).trimStart();
+    }
+    const lineFiltered = remaining
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => !salvageFunctionLikeToolCall(line))
+        .join("\n")
+        .trim();
+    if (lineFiltered.length > 0) {
+        const prefixedToolCallMatch = /^(?:\s*(?:Ready|Understood|Okay|Ok|Got it|Sure|All set|Please provide a task for me to orchestrate)[.:!]?\s*)+([A-Za-z_][A-Za-z0-9_]*\([\s\S]*\))\s*$/u.exec(lineFiltered);
+        if (prefixedToolCallMatch && salvageFunctionLikeToolCall(prefixedToolCallMatch[1])) {
+            return "";
+        }
+        return lineFiltered;
+    }
+    return removedLeadingCall ? "" : value.trim();
+}
 export function sanitizeVisibleText(value) {
-    return value
+    return stripVisibleFunctionLikeToolCallText(value
         .replace(/[A-Za-z0-9_]*Middleware\.after_model/g, "")
         .replace(/todoListMiddleware\.after_model/g, "")
         .replace(/__end__+/g, "")
-        .trim();
+        .trim());
 }
 function isLikelyMemoryWriteArgsObject(value) {
     if (typeof value !== "object" || !value || Array.isArray(value)) {
@@ -104,7 +186,7 @@ function extractAssistantTextFromMessages(messages) {
             const content = extractMessageContent(message);
             if (content)
                 return content;
-            continue;
+            return "";
         }
         const ids = Array.isArray(typed.id) ? typed.id.filter((item) => typeof item === "string") : [];
         const typeName = ids.at(-1);
@@ -123,6 +205,7 @@ function extractAssistantTextFromMessages(messages) {
         const content = extractMessageContent(message);
         if (content)
             return content;
+        return "";
     }
     return "";
 }

package/package.json

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