@botbotgo/agent-harness 0.0.392 → 0.0.394

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.392";
+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.392";
+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) {
@@ -61,12 +62,48 @@ function hasIncompletePlanStateInExecutedToolResults(executedToolResults) {
     }
     return false;
 }
+function hasIncompleteTodosArray(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.some((todo) => typeof todo === "object"
+        && todo !== null
+        && typeof todo.status === "string"
+        && ["pending", "in_progress"].includes(todo.status.trim().toLowerCase()));
+}
+function hasIncompletePlanOutput(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const typed = value;
+    if (typeof typed.pending === "number" || typeof typed.inProgress === "number") {
+        return (typeof typed.pending === "number" ? typed.pending : 0) > 0
+            || (typeof typed.inProgress === "number" ? typed.inProgress : 0) > 0;
+    }
+    const directTodos = hasIncompleteTodosArray(typed.todos);
+    if (directTodos !== null) {
+        return directTodos;
+    }
+    for (const nested of [typed.summary, typed.update, typed.data, typed.output]) {
+        const nestedCompleteness = hasIncompletePlanOutput(nested);
+        if (nestedCompleteness !== null) {
+            return nestedCompleteness;
+        }
+    }
+    return null;
+}
 function isPlanToolName(toolName) {
     return toolName === "write_todos"
         || toolName === "read_todos"
         || toolName === "tool_call_write_todos"
         || toolName === "tool_call_read_todos";
 }
+function isCompletedPlanToolResultChunk(chunk) {
+    if (chunk.kind !== "tool-result" || !isPlanToolName(chunk.toolName)) {
+        return false;
+    }
+    return hasIncompletePlanOutput(chunk.output) === false;
+}
 function hasNonTodoToolEvidence(executedToolResults) {
     return executedToolResults.some((item) => !isPlanToolName(item.toolName));
 }
@@ -128,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 {
@@ -460,6 +517,9 @@ export async function* streamRuntimeExecution(options) {
                 if (shouldProfile)
                     yield streamEventsConsume.chunk;
                 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,
@@ -484,18 +544,46 @@ 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;
+                            }
+                            if (isCompletedPlanToolResultChunk(chunk)) {
+                                sawCompletedPlanToolResult = true;
+                            }
                             if ((eventContainsNonTodoToolResult || eventContainsNonRetrySafeChunk) && deferredStreamContent.length > 0) {
                                 yield* flushDeferredStreamContent();
                             }
                             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) {
+                            deferredStreamContent.length = 0;
+                            yield { kind: "content", content: buildDeterministicFinalFromStreamToolEvidence(streamedToolResults) };
+                            return;
+                        }
+                        const eventExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
+                        if (requiresPlanEvidence(options.binding) && hasCompletedPlanWithEvidence(eventExecutionEvidence)) {
+                            deferredStreamContent.length = 0;
+                            yield { kind: "content", content: buildDeterministicFinalFromStreamToolEvidence(streamedToolResults) };
+                            return;
+                        }
                         const terminalVisibleOutput = readTerminalEventVisibleOutput(event);
                         if (terminalVisibleOutput) {
                             const terminalExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });

package/package.json

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