@botbotgo/agent-harness 0.0.393 → 0.0.394

package/dist/package-version.d.ts

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

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

@@ -5,6 +5,7 @@ import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
 import { projectTextStreamChunks } from "../stream-text-consumption.js";
 import { computeRemainingTimeoutMs } from "../resilience.js";
+import { stringifyToolOutput } from "../tool/tool-arguments.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../upstream-configurable-keys.js";
 export class ExecutionReconciliationError extends Error {
     constructor(message) {
@@ -164,6 +165,26 @@ function hasCompletedPlanWithEvidence(evidence) {
         && !hasMissingDelegatedExecutionEvidence(evidence)
         && !hasMissingDelegatedFindings(evidence);
 }
+function buildDeterministicFinalFromStreamToolEvidence(executedToolResults) {
+    const evidence = executedToolResults
+        .filter((item) => item.isError !== true && !isPlanToolName(item.toolName))
+        .map((item) => {
+        const visible = toVisibleContent(item.output);
+        const raw = visible || stringifyToolOutput(item.output).trim();
+        const clipped = raw.length > 4000 ? `${raw.slice(0, 4000)}\n... [truncated]` : raw;
+        return `## ${item.toolName}\n${clipped}`;
+    });
+    return [
+        "Status: completed",
+        "",
+        "Summary:",
+        "- Completed the required TODO burn down after collecting tool evidence.",
+        "- Returning an evidence-grounded deterministic summary because the streamed model did not produce a clean final synthesis before the required plan completed.",
+        "",
+        "Evidence:",
+        evidence.length > 0 ? evidence.join("\n\n") : "(no non-planning tool evidence captured)",
+    ].join("\n");
+}
 function readBindingExecutionParams(binding) {
     const params = binding.execution?.params ?? binding.deepAgentParams ?? binding.langchainAgentParams;
     return {
@@ -498,6 +519,7 @@ export async function* streamRuntimeExecution(options) {
                 try {
                     let sawCompletedPlanToolResult = false;
                     let sawSuccessfulNonTodoToolResult = false;
+                    const streamedToolResults = [];
                     for await (const event of options.iterateWithTimeout(events, options.streamIdleTimeoutMs, "agent streamEvents", options.streamDeadlineAt, options.invokeTimeoutMs)) {
                         const projectedChunks = projectRuntimeStreamEvent({
                             event,
@@ -522,6 +544,13 @@ export async function* streamRuntimeExecution(options) {
                             if (chunk.kind === "tool-result" && chunk.isError === true && isRetrySafeInvalidToolSelectionError(chunk.output)) {
                                 sawRetrySafeInvalidToolSelectionError = true;
                             }
+                            if (chunk.kind === "tool-result") {
+                                streamedToolResults.push({
+                                    toolName: chunk.toolName,
+                                    output: chunk.output,
+                                    isError: chunk.isError,
+                                });
+                            }
                             if (chunk.kind === "tool-result" && !isPlanToolName(chunk.toolName) && chunk.isError !== true) {
                                 sawSuccessfulNonTodoToolResult = true;
                             }
@@ -534,23 +563,25 @@ export async function* streamRuntimeExecution(options) {
                             if (eventContainsNonTodoToolResult || eventContainsNonRetrySafeChunk) {
                                 emittedUnsafeStreamSideEffects = true;
                             }
-                            if (chunk.kind === "content" && (shouldDeferStreamContent() || projectionState.hasFailedTaskDelegation)) {
+                            const shouldDeferRequiredPlanContent = requiresPlanEvidence(options.binding)
+                                && projectionState.sawPlanState
+                                && !hasCompletedPlanWithEvidence(buildExecutionRecoveryEvidence({ projectionState }));
+                            if (chunk.kind === "content"
+                                && (shouldDeferStreamContent() || projectionState.hasFailedTaskDelegation || shouldDeferRequiredPlanContent)) {
                                 deferredStreamContent.push(chunk);
                                 continue;
                             }
                             yield chunk;
                         }
                         if (requiresPlanEvidence(options.binding) && sawCompletedPlanToolResult && sawSuccessfulNonTodoToolResult) {
-                            if (deferredStreamContent.length > 0) {
-                                yield* flushDeferredStreamContent();
-                            }
+                            deferredStreamContent.length = 0;
+                            yield { kind: "content", content: buildDeterministicFinalFromStreamToolEvidence(streamedToolResults) };
                             return;
                         }
                         const eventExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
                         if (requiresPlanEvidence(options.binding) && hasCompletedPlanWithEvidence(eventExecutionEvidence)) {
-                            if (deferredStreamContent.length > 0) {
-                                yield* flushDeferredStreamContent();
-                            }
+                            deferredStreamContent.length = 0;
+                            yield { kind: "content", content: buildDeterministicFinalFromStreamToolEvidence(streamedToolResults) };
                             return;
                         }
                         const terminalVisibleOutput = readTerminalEventVisibleOutput(event);

package/package.json

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