@botbotgo/agent-harness 0.0.343 → 0.0.344

package/dist/cli/chat-stream.js

@@ -184,7 +184,7 @@ export async function streamChatMessage(input) {
     };
     const scheduleIdleProgress = () => {
         clearIdleProgressTimer();
-        if (idleProgressMs <= 0 || wroteContent || wroteRenderableBlocks) {
+        if (idleProgressMs <= 0) {
             return;
         }
         idleProgressTimer = setTimeout(() => {

package/dist/cli/chat-workspace.js

@@ -161,10 +161,12 @@ export function renderChatRuntimeFailure(output, modelInfo) {
     if (!normalized.includes("fetch failed") &&
         !normalized.includes("connection error") &&
         !normalized.includes("timed out") &&
+        !normalized.includes("error 524") &&
         !normalized.includes("404 page not found")) {
         return output;
     }
     const lines = [trimmed];
+    const isTimeoutStyleError = /(\berror 524\b|\btimeout\b|\btimed out\b)/i.test(trimmed);
     if (modelInfo?.provider || modelInfo?.model) {
         lines.push(`provider=${modelInfo?.provider ?? "unknown"}${modelInfo?.model ? ` model=${modelInfo.model}` : ""}`);
     }
@@ -178,6 +180,9 @@ export function renderChatRuntimeFailure(output, modelInfo) {
     if (hint) {
         lines.push(hint);
     }
+    if (isTimeoutStyleError) {
+        lines.push("Hint: this usually indicates the model endpoint dropped the connection before producing a full answer.");
+    }
     return lines.join("\n");
 }
 export async function probeChatWorkspace(input) {

package/dist/cli.js

@@ -4,5 +4,5 @@ import { runCli, resolveInvokedCliHref } from "./cli/main.js";
 const invokedPath = resolveInvokedCliHref(process.argv[1]);
 if (import.meta.url === invokedPath) {
     const exitCode = await runCli(process.argv.slice(2));
-    process.exitCode = exitCode;
+    process.exit(exitCode);
 }

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.343";
+export declare const AGENT_HARNESS_VERSION = "0.0.344";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.343";
+export const AGENT_HARNESS_VERSION = "0.0.344";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

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

@@ -84,6 +84,19 @@ function hasMissingDelegatedExecutionEvidence(evidence) {
 function hasMissingDelegatedFindings(evidence) {
     return evidence.hasDelegatedAgentWithConfiguredTools && evidence.hasOnlyPlaceholderTaskCompletion;
 }
+function isRuntimeFailureOutput(value) {
+    return value.trim().startsWith("runtime_error=");
+}
+function resolveStreamedRuntimeFailureRecoveryInstruction(output, evidence) {
+    if (!isRuntimeFailureOutput(output)) {
+        return null;
+    }
+    const hasExecutionEvidence = evidence.hasToolResultEvidence
+        || evidence.hasPlanStateEvidence
+        || evidence.hasOpenTaskDelegation
+        || evidence.hasDelegatedExecutionToolEvidence;
+    return hasExecutionEvidence ? null : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;
+}
 function resolveDelegatedExecutionRecoveryInstruction(evidence) {
     if (hasMissingDelegatedFindings(evidence)
         || (evidence.hasOpenTaskDelegation
@@ -442,6 +455,9 @@ export async function* streamRuntimeExecution(options) {
                     hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(streamedExecutionEvidence),
                 })
                 : null;
+            const streamedRuntimeFailureRecoveryInstruction = projectionState.emittedOutput
+                ? resolveStreamedRuntimeFailureRecoveryInstruction(projectionState.emittedOutput, streamedExecutionEvidence)
+                : null;
             const missingPlanRecoveryInstruction = !hasUnresolvedExecution(streamedExecutionEvidence) && !delegatedExecutionRecoveryInstruction
                 ? resolveMissingPlanRecoveryInstruction({
                     request,
@@ -453,7 +469,10 @@ export async function* streamRuntimeExecution(options) {
                 : null;
             const retryInstruction = !emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError
                 ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION
-                : delegatedExecutionRecoveryInstruction ?? missingPlanRecoveryInstruction ?? executionWithoutToolEvidenceInstruction;
+                : delegatedExecutionRecoveryInstruction
+                    ?? streamedRuntimeFailureRecoveryInstruction
+                    ?? missingPlanRecoveryInstruction
+                    ?? executionWithoutToolEvidenceInstruction;
             if (retryInstruction) {
                 let retried;
                 retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, retryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);

package/dist/runtime/adapter/resilience.js

@@ -32,6 +32,10 @@ export function resolveStreamIdleTimeout(binding) {
 }
 const BUILTIN_RETRYABLE_PROVIDER_MESSAGES = [
     "unexpected eof",
+    "other side closed",
+    "socket hang up",
+    "connection reset",
+    "econnreset",
 ];
 function isEmptyFinalAiMessageError(error) {
     const message = error instanceof Error ? error.message : String(error);

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

@@ -332,7 +332,16 @@ function normalizeStreamChunk(chunk) {
     return { kind: "content", content: chunk.content ?? "" };
 }
 function normalizeCommentaryText(value) {
-    return value.replace(/\s+/g, " ").trim();
+    return value
+        .split("\n")
+        .map((line) => {
+        const leading = /^\s*/.exec(line)?.[0] ?? "";
+        const body = line.slice(leading.length).replace(/[^\S\n]+/g, " ").trimEnd();
+        return `${leading}${body}`;
+    })
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
 }
 function ensureCommentarySentence(value) {
     const normalized = normalizeCommentaryText(value);
@@ -359,9 +368,9 @@ function summarizePlanState(planState) {
                 return "[ ]";
         }
     };
-    const items = planState.items.slice(0, 6).map((item) => `${statusMarker(item.status)} ${item.content}`);
-    const suffix = planState.items.length > items.length ? ` | +${planState.items.length - items.length} more` : "";
-    return `TODO: ${items.join(" | ")}${suffix}`;
+    const items = planState.items.slice(0, 6).map((item) => `  ${statusMarker(item.status)} ${item.content}`);
+    const suffix = planState.items.length > items.length ? [`  ... ${planState.items.length - items.length} more`] : [];
+    return ["TODO", ...items, ...suffix].join("\n");
 }
 function summarizePlanStateTerminalTransitions(previousPlanState, nextPlanState) {
     const previousByKey = new Map((previousPlanState?.items ?? []).map((item) => [normalizePlanItemKey(item), item]));
@@ -523,6 +532,45 @@ function createRuntimeMemoryRecallSteps(sessionId, requestId, items) {
         },
     ];
 }
+function readObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function isFallbackSafeUpstreamStartupEvent(event, rootAgentId) {
+    const typed = readObject(event);
+    const eventName = typeof typed?.event === "string" ? typed.event : "";
+    if (eventName.startsWith("on_chat_model_") || eventName.startsWith("on_llm_")) {
+        return true;
+    }
+    if (!eventName.startsWith("on_chain_")) {
+        return false;
+    }
+    if (typed?.run_type === "tool") {
+        return false;
+    }
+    const name = typeof typed?.name === "string" ? typed.name : "";
+    const metadata = readObject(typed?.metadata);
+    const langgraphNode = typeof metadata?.langgraph_node === "string" ? metadata.langgraph_node : "";
+    const langchainAgentName = typeof metadata?.lc_agent_name === "string" ? metadata.lc_agent_name : "";
+    return (name === "__start__"
+        || langgraphNode === "__start__"
+        || langgraphNode === "model_request"
+        || name.endsWith(".before_agent")
+        || name.endsWith(".before_model")
+        || (name === rootAgentId && langchainAgentName === rootAgentId));
+}
+function planStateHasAnyItems(planState) {
+    return (planState?.items.length ?? 0) > 0;
+}
+function isStartupRuntimeFailureOutput(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized.startsWith("runtime_error=")) {
+        return false;
+    }
+    return ((normalized.includes("terminated") && normalized.includes("other side closed"))
+        || normalized.includes("socket hang up")
+        || normalized.includes("connection reset")
+        || normalized.includes("econnreset"));
+}
 export async function* streamHarnessRun(options) {
     const priorHistoryPromise = Promise.resolve(options.isNewSession ? [] : undefined).then((historyHint) => historyHint ?? options.loadPriorHistory(options.sessionId, options.requestId));
     yield { type: "event", event: await options.requestCreatedEventPromise };
@@ -533,6 +581,7 @@ export async function* streamHarnessRun(options) {
     let emitted = false;
     let streamActivityObserved = false;
     let nonUpstreamStreamActivityObserved = false;
+    let observedOnlyFallbackSafeUpstreamEvents = true;
     let assistantOutput = "";
     let assistantOutputCameFromInvokeFallback = false;
     const bufferAssistantTextUntilCompletion = true;
@@ -589,6 +638,9 @@ export async function* streamHarnessRun(options) {
             streamActivityObserved = true;
             const normalizedChunk = normalizeStreamChunk(rawChunk);
             if (normalizedChunk.kind === "upstream-event") {
+                if (!isFallbackSafeUpstreamStartupEvent(normalizedChunk.event, options.selectedAgentId)) {
+                    observedOnlyFallbackSafeUpstreamEvents = false;
+                }
                 const upstreamPlanState = getPlanStateFromUpstreamEvent({
                     sessionId: options.sessionId,
                     requestId: options.requestId,
@@ -833,6 +885,15 @@ export async function* streamHarnessRun(options) {
             emitted = emitted || assistantOutput.length > 0;
         }
         currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
+        if (assistantOutput
+            && isStartupRuntimeFailureOutput(assistantOutput)
+            && executedToolResults.length === 0
+            && !sawSuccessfulToolResult
+            && observedOnlyFallbackSafeUpstreamEvents
+            && !planStateHasAnyItems(currentPlanState)) {
+            assistantOutput = "";
+            emitted = false;
+        }
         if (!assistantOutput) {
             const actual = await options.invokeWithHistory(options.binding, options.input, options.sessionId, options.requestId);
             if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
@@ -1019,8 +1080,12 @@ export async function* streamHarnessRun(options) {
         }
         const shouldRetryAfterStreamingCompatibilityError = !assistantOutput &&
             isOpenAICompatibleStreamingCompatibilityError(options.binding, error);
-        if ((emitted || streamActivityObserved)
-            && !shouldRetryAfterStreamingCompatibilityError) {
+        const streamHadExecutionSideEffects = emitted
+            || nonUpstreamStreamActivityObserved
+            || sawSuccessfulToolResult
+            || executedToolResults.length > 0
+            || !observedOnlyFallbackSafeUpstreamEvents;
+        if (streamHadExecutionSideEffects && !shouldRetryAfterStreamingCompatibilityError) {
             const runtimeFailure = renderRuntimeFailure(error);
             const detailedError = describeRuntimeError(error);
             yield {

package/dist/runtime/harness.d.ts

@@ -132,6 +132,7 @@ export declare class AgentHarnessRuntime {
     private emit;
     private trackBackgroundTask;
     private scheduleBackgroundStartupTask;
+    private drainBackgroundTasksForClose;
     private resolveToolMcpServerTools;
     private loadPriorHistory;
     private loadRequestInput;

package/dist/runtime/harness.js

@@ -46,6 +46,7 @@ import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-ru
 import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessionRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/session-records.js";
 import { createKnowledgeModule } from "../knowledge/index.js";
 import { createProceduralMemoryManager, ProceduralMemoryFormationSync, readProceduralMemoryRuntimeConfig, } from "../knowledge/procedural/index.js";
+const BACKGROUND_TASK_CLOSE_DRAIN_TIMEOUT_MS = 1_000;
 const ACTIVE_REQUEST_STATES = [
     "queued",
     "claimed",
@@ -945,6 +946,23 @@ export class AgentHarnessRuntime {
     scheduleBackgroundStartupTask(task) {
         this.trackBackgroundTask(task.then(() => undefined).catch(() => undefined));
     }
+    async drainBackgroundTasksForClose() {
+        const tasks = Array.from(this.backgroundTasks);
+        if (tasks.length === 0) {
+            return;
+        }
+        let timeoutHandle;
+        await Promise.race([
+            Promise.allSettled(tasks),
+            new Promise((resolve) => {
+                timeoutHandle = setTimeout(resolve, BACKGROUND_TASK_CLOSE_DRAIN_TIMEOUT_MS);
+                timeoutHandle.unref?.();
+            }),
+        ]);
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
     resolveToolMcpServerTools(agentId) {
         return resolveWorkspaceAgentTools({
             workspace: this.workspace,
@@ -1375,7 +1393,7 @@ export class AgentHarnessRuntime {
         this.unregisterMem0IngestionSync();
         this.unregisterRuntimeMemoryFormationSync();
         this.unregisterProceduralMemoryFormationSync();
-        await Promise.allSettled(Array.from(this.backgroundTasks));
+        await this.drainBackgroundTasksForClose();
         await this.sessionMemorySync?.close();
         await this.runtimeMemorySync?.close();
         await this.mem0IngestionSync?.close();

package/package.json

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