@botbotgo/agent-harness 0.0.327 → 0.0.328

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

@@ -1,16 +1,13 @@
 import { MemorySaver } from "@langchain/langgraph";
-import { createFilesystemMiddleware, createPatchToolCallsMiddleware } from "deepagents";
-import { todoListMiddleware } from "langchain";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
 import { asStructuredExecutableTool } from "./adapter/tool/resolved-tool.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
-import { getBindingBackendConfig, getBindingDeepAgentSubagents, getBindingExecutionKind, getBindingExecutionParams, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryTools, getBindingSkills, getBindingStoreConfig, } from "./support/compiled-binding.js";
+import { getBindingBackendConfig, getBindingExecutionKind, getBindingExecutionParams, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryTools, getBindingSkills, getBindingStoreConfig, } from "./support/compiled-binding.js";
 export const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES = new Set([
     "list_files",
     "search_files",
     "run_command",
-    "delegate_task",
 ]);
 const MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES = new Set([
     "fetch_url",
@@ -145,65 +142,16 @@ export function buildDeepAgentCreateParams(input) {
         ...(input.resolvedBackend !== undefined ? { backend: input.resolvedBackend } : {}),
     };
 }
-export function shouldUseMinimalDeepAgentAssembly(input) {
-    const executionKind = getBindingExecutionKind(input.binding);
-    if (executionKind !== "deepagent") {
-        return false;
-    }
-    if (input.resolvedBackend === undefined) {
-        return false;
-    }
-    if (input.resolvedSkills.length > 0) {
-        return false;
-    }
-    if (input.resolvedSubagents.length > 0 || getBindingDeepAgentSubagents(input.binding).length > 0) {
-        return false;
-    }
-    if (getBindingMemorySources(input.binding).length > 0) {
-        return false;
-    }
-    if (input.resolvedMiddleware.length > 0 || (getBindingMiddlewareConfigs(input.binding)?.length ?? 0) > 0) {
-        return false;
-    }
-    return input.resolvedInterruptOn === undefined || Object.keys(input.resolvedInterruptOn).length === 0;
-}
-export function buildMinimalDeepAgentCreateParams(input) {
-    const executionKind = getBindingExecutionKind(input.binding);
-    if (executionKind !== "deepagent" || !getBindingExecutionParams(input.binding)) {
-        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
-    }
-    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
-        "systemPrompt",
-        "contextSchema",
-        "responseFormat",
-        "name",
-        "description",
-        "includeAgentName",
-        "version",
-    ]);
-    return {
-        ...upstreamParams,
-        model: input.resolvedModel,
-        tools: input.resolvedTools,
-        middleware: [
-            todoListMiddleware(),
-            createFilesystemMiddleware({ backend: input.resolvedBackend }),
-            createPatchToolCallsMiddleware(),
-        ],
-        ...(input.resolvedCheckpointer !== undefined ? { checkpointer: input.resolvedCheckpointer } : {}),
-        ...(input.resolvedStore !== undefined ? { store: input.resolvedStore } : {}),
-    };
-}
-export function shouldAttachMinimalDeepAgentCheckpointer(binding, resolvedInterruptOn) {
+export function shouldAttachDeepAgentCheckpointer(binding, resolvedInterruptOn) {
     if (binding.harnessRuntime.checkpointer !== undefined) {
         return true;
     }
     return resolvedInterruptOn !== undefined && Object.keys(resolvedInterruptOn).length > 0;
 }
-export function shouldAttachMinimalDeepAgentStore(binding) {
+export function shouldAttachDeepAgentStore(binding) {
     return getBindingStoreConfig(binding) !== undefined || getBindingMemorySources(binding).length > 0;
 }
-export function shouldAttachMinimalDeepAgentBackend(binding) {
+export function shouldAttachDeepAgentBackend(binding) {
     return (getBindingBackendConfig(binding) !== undefined ||
         getBindingMemorySources(binding).length > 0 ||
         getBindingSkills(binding).length > 0 ||

package/dist/runtime/harness/run/inspection.js

@@ -26,6 +26,16 @@ function isTaskDelegationCompletionEvent(event) {
     return ((eventName === "on_tool_end" && name === "task")
         || (eventName === "on_chain_end" && runType === "tool" && name === "task"));
 }
+function isTaskDelegationFailureEvent(event) {
+    const eventName = typeof event.event === "string" ? event.event : "";
+    const name = typeof event.name === "string" ? event.name : "";
+    const runType = typeof event.run_type === "string" ? event.run_type : "";
+    return ((eventName === "on_tool_error" && name === "task")
+        || (eventName === "on_chain_error" && runType === "tool" && name === "task"));
+}
+function isTaskDelegationTerminalEvent(event) {
+    return isTaskDelegationCompletionEvent(event) || isTaskDelegationFailureEvent(event);
+}
 function readTracingConfig(binding) {
     const deepAgentTracing = asObject(binding.harnessRuntime?.deepagent?.passthrough)?.tracing;
     const langchainTracing = asObject(binding.harnessRuntime?.langchain?.passthrough)?.tracing;
@@ -152,9 +162,7 @@ function extractSubagentFromTaskToolEvent(event) {
     const input = asObject(data?.input);
     const subagentType = typeof input?.subagent_type === "string"
         ? input.subagent_type
-        : typeof input?.subagentType === "string"
-            ? input.subagentType
-            : null;
+        : null;
     return subagentType && subagentType.trim().length > 0 ? subagentType.trim() : null;
 }
 function extractKnownSubagentFromEvent(event, knownSubagentIds) {
@@ -175,6 +183,14 @@ export function consumeRunInspectionUpstreamEvent(input) {
     }
     const knownSubagentIds = new Set(getBindingSubagents(input.binding).map((subagent) => subagent.name));
     const delegatedAgentId = extractSubagentFromTaskToolEvent(typed) ?? extractKnownSubagentFromEvent(typed, knownSubagentIds);
+    if (isTaskDelegationTerminalEvent(typed) && input.delegationChain.length > 1) {
+        const nextDelegationChain = input.delegationChain.slice(0, -1);
+        const nextAgentId = nextDelegationChain.at(-1) ?? input.currentAgentId;
+        return {
+            currentAgentId: nextAgentId,
+            delegationChain: nextDelegationChain,
+        };
+    }
     if (!delegatedAgentId) {
         return {
             currentAgentId: input.currentAgentId,
@@ -299,7 +315,7 @@ export function projectRuntimeSurfaceFromSingleUpstreamEvent(input) {
                 },
             });
         }
-        if (isTaskDelegationCompletionEvent(typed) && previousDelegationChain.length > 1) {
+        if (isTaskDelegationTerminalEvent(typed) && previousDelegationChain.length > 1) {
             const delegatedAgentId = previousDelegationChain.at(-1);
             const ownerAgentId = previousDelegationChain.at(-2);
             const delegatedAgentName = formatAgentName(delegatedAgentId);
@@ -308,7 +324,7 @@ export function projectRuntimeSurfaceFromSingleUpstreamEvent(input) {
                 id: buildSurfaceId("agent", delegatedAgentId),
                 name: delegatedAgentName,
                 action: "handoff",
-                status: "completed",
+                status: isTaskDelegationFailureEvent(typed) ? "failed" : "completed",
                 agentId: delegatedAgentId,
                 agentName: delegatedAgentName,
                 ...(ownerAgentId ? { ownerAgentId, ownerAgentName: formatAgentName(ownerAgentId) } : {}),

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

@@ -1,3 +1,4 @@
+import { describeRuntimeError } from "../../support/harness-support.js";
 import { isTerminalRequestState } from "./helpers.js";
 async function finalizeIfCancellationRequested(input) {
     const cancellation = await input.getRequestCancellation(input.requestId);
@@ -200,7 +201,7 @@ export async function executeQueuedRequestOperation(runtime, input) {
         await runtime.emitSyntheticFallback(sessionId, requestId, agentId, error);
         await runtime.setRequestStateAndEmit(sessionId, requestId, 104, "failed", {
             previousState: continuationState,
-            error: error instanceof Error ? error.message : String(error),
+            error: describeRuntimeError(error),
         });
         return {
             sessionId: sessionId,

package/dist/runtime/harness/run/stream-run.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, HarnessEvent, MemoryRecord, MessageContent, RequestResult, RequestExecutionStep, RuntimeSnapshot, TranscriptMessage } from "../../../contracts/types.js";
+import type { CompiledAgentBinding, HarnessEvent, MemoryRecord, MessageContent, RequestPlanState, RequestResult, RequestExecutionStep, RuntimeSnapshot, TranscriptMessage } from "../../../contracts/types.js";
 import { type InternalHarnessStreamItem } from "../events/streaming.js";
 type RuntimeStreamChunk = {
     kind: "commentary";
@@ -65,6 +65,8 @@ type StreamRunOptions = {
         runtimeSnapshot?: RuntimeSnapshot | null;
     }) => Promise<void>;
     appendRequestTraceItem: (sessionId: string, requestId: string, item: unknown) => Promise<void>;
+    loadRequestPlanState?: (sessionId: string, requestId: string) => Promise<RequestPlanState | null>;
+    saveRequestPlanState?: (sessionId: string, requestId: string, planState: RequestPlanState) => Promise<void>;
     emitSyntheticFallback: (sessionId: string, requestId: string, selectedAgentId: string, error: unknown) => Promise<void>;
 };
 export declare function streamHarnessRun(options: StreamRunOptions): AsyncGenerator<InternalHarnessStreamItem>;

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

@@ -1,6 +1,7 @@
 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 { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
+import { describeRuntimeError, renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
 import { createContentBlocksItem, createToolResultKey, } from "../events/streaming.js";
 import { projectRuntimeSurfaceFromSingleUpstreamEvent } from "./inspection.js";
@@ -19,10 +20,64 @@ function createInitialPlanState(sessionId, requestId, updatedAt) {
             completed: 0,
             failed: 0,
             cancelled: 0,
-            blocked: 0,
         },
     };
 }
+function planStateHasUnfinishedItems(planState) {
+    if (!planState) {
+        return false;
+    }
+    return planState.summary.pending > 0 || planState.summary.inProgress > 0;
+}
+function planStateHasActiveItems(planState) {
+    if (!planState) {
+        return false;
+    }
+    return planState.summary.pending > 0 || planState.summary.inProgress > 0;
+}
+function readTerminalStructuredStatus(value) {
+    if (typeof value === "string") {
+        try {
+            return readTerminalStructuredStatus(JSON.parse(value));
+        }
+        catch {
+            return null;
+        }
+    }
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const typed = value;
+    if (typed.status === "completed") {
+        return typed.status;
+    }
+    return (readTerminalStructuredStatus(typed.structuredResponse)
+        ?? readTerminalStructuredStatus(typed.output)
+        ?? readTerminalStructuredStatus(typed.data));
+}
+function reconcilePlanStateToTerminalStatus(planState, status, updatedAt) {
+    const items = planState.items.map((item) => ({
+        ...item,
+        status: item.status === "pending" || item.status === "in_progress"
+            ? status
+            : item.status,
+    }));
+    const summary = {
+        total: items.length,
+        pending: 0,
+        inProgress: 0,
+        completed: items.filter((item) => item.status === "completed").length,
+        failed: items.filter((item) => item.status === "failed").length,
+        cancelled: items.filter((item) => item.status === "cancelled").length,
+    };
+    return {
+        ...planState,
+        version: planState.version + 1,
+        updatedAt,
+        items,
+        summary,
+    };
+}
 function getPlanStateFromToolResult(input) {
     if (typeof input.output !== "object" || input.output === null) {
         return null;
@@ -80,6 +135,26 @@ function buildPlanStateSignature(planState) {
 function countStructuredTodoIds(items) {
     return items.filter((item) => typeof item.id === "string" && item.id.length > 0).length;
 }
+async function emitPlanStateUpdate(options, agentId, planState) {
+    await options.saveRequestPlanState?.(options.sessionId, options.requestId, planState);
+    return [{
+            type: "plan-state",
+            sessionId: options.sessionId,
+            requestId: options.requestId,
+            agentId,
+            planState,
+        }];
+}
+async function refreshPlanStateFromPersistence(options, currentPlanState) {
+    const persistedPlanState = await options.loadRequestPlanState?.(options.sessionId, options.requestId);
+    if (!persistedPlanState) {
+        return currentPlanState;
+    }
+    if (!currentPlanState || persistedPlanState.version >= currentPlanState.version) {
+        return persistedPlanState;
+    }
+    return currentPlanState;
+}
 function shouldEmitPlanState(currentPlanState, nextPlanState) {
     if (!currentPlanState || currentPlanState.items.length === 0) {
         return true;
@@ -210,7 +285,6 @@ function summarizePlanState(planState) {
         planState.summary.inProgress > 0 ? `${planState.summary.inProgress} in progress` : "",
         planState.summary.pending > 0 ? `${planState.summary.pending} pending` : "",
         planState.summary.completed > 0 ? `${planState.summary.completed} completed` : "",
-        planState.summary.blocked > 0 ? `${planState.summary.blocked} blocked` : "",
         planState.summary.failed > 0 ? `${planState.summary.failed} failed` : "",
     ].filter((value) => value.length > 0);
     if (counts.length === 0) {
@@ -228,6 +302,9 @@ function createSurfaceCommentary(surfaceItem) {
             return `Running tool ${name}.`;
         }
         if (surfaceItem.status === "completed") {
+            if (name.toLowerCase() === "task") {
+                return null;
+            }
             return `Tool ${name} completed.`;
         }
         if (surfaceItem.status === "failed") {
@@ -252,7 +329,7 @@ function createSurfaceCommentary(surfaceItem) {
             return `Delegating work to ${name}.`;
         }
         if (surfaceItem.status === "completed") {
-            return `Delegation to ${name} completed.`;
+            return null;
         }
         if (surfaceItem.status === "failed") {
             return `Delegation to ${name} failed.`;
@@ -360,6 +437,7 @@ export async function* streamHarnessRun(options) {
     let streamActivityObserved = false;
     let nonUpstreamStreamActivityObserved = false;
     let assistantOutput = "";
+    let assistantOutputCameFromInvokeFallback = false;
     const bufferAssistantTextUntilCompletion = true;
     let currentAgentId = options.selectedAgentId;
     let currentAgentName = formatAgentName(options.selectedAgentId);
@@ -425,19 +503,32 @@ export async function* streamHarnessRun(options) {
                         planStateVersion = upstreamPlanState.version;
                         lastPlanStateSignature = signature;
                         currentPlanState = upstreamPlanState;
-                        yield {
-                            type: "plan-state",
-                            sessionId: options.sessionId,
-                            requestId: options.requestId,
-                            agentId: currentAgentId,
-                            planState: upstreamPlanState,
-                        };
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, upstreamPlanState)) {
+                            yield item;
+                        }
                         const commentary = summarizePlanState(upstreamPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
                     }
                 }
+                const terminalStructuredStatus = readTerminalStructuredStatus(normalizedChunk.event);
+                if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
+                    const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                    const signature = buildPlanStateSignature(reconciledPlanState);
+                    if (signature !== lastPlanStateSignature) {
+                        planStateVersion = reconciledPlanState.version;
+                        lastPlanStateSignature = signature;
+                        currentPlanState = reconciledPlanState;
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                            yield item;
+                        }
+                        const commentary = summarizePlanState(reconciledPlanState);
+                        if (commentary) {
+                            yield* emitCommentary(commentary);
+                        }
+                    }
+                }
                 upstreamEventOrdinal += 1;
                 const projectionBinding = options.getBinding(currentAgentId) ?? options.binding;
                 const surfaceProjection = projectRuntimeSurfaceFromSingleUpstreamEvent({
@@ -578,19 +669,32 @@ export async function* streamHarnessRun(options) {
                     if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, planState)) {
                         lastPlanStateSignature = signature;
                         currentPlanState = planState;
-                        yield {
-                            type: "plan-state",
-                            sessionId: options.sessionId,
-                            requestId: options.requestId,
-                            agentId: currentAgentId,
-                            planState,
-                        };
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, planState)) {
+                            yield item;
+                        }
                         const commentary = summarizePlanState(planState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
                     }
                 }
+                const terminalStructuredStatus = readTerminalStructuredStatus(normalizedChunk.output);
+                if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
+                    const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                    const signature = buildPlanStateSignature(reconciledPlanState);
+                    if (signature !== lastPlanStateSignature) {
+                        planStateVersion = reconciledPlanState.version;
+                        lastPlanStateSignature = signature;
+                        currentPlanState = reconciledPlanState;
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                            yield item;
+                        }
+                        const commentary = summarizePlanState(reconciledPlanState);
+                        if (commentary) {
+                            yield* emitCommentary(commentary);
+                        }
+                    }
+                }
                 continue;
             }
             emitted = true;
@@ -614,6 +718,7 @@ export async function* streamHarnessRun(options) {
             assistantOutput = toolErrors.join("\n\n");
             emitted = true;
         }
+        currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
         if (!assistantOutput) {
             const actual = await options.invokeWithHistory(options.binding, options.input, options.sessionId, options.requestId);
             if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
@@ -622,6 +727,7 @@ export async function* streamHarnessRun(options) {
             if (actual.output) {
                 assistantOutput = actual.output;
                 emitted = true;
+                assistantOutputCameFromInvokeFallback = true;
             }
             const finalPlanState = getLatestPlanStateFromExecutedToolResults({
                 sessionId: options.sessionId,
@@ -636,19 +742,42 @@ export async function* streamHarnessRun(options) {
                     planStateVersion = finalPlanState.version;
                     lastPlanStateSignature = signature;
                     currentPlanState = finalPlanState;
-                    yield {
-                        type: "plan-state",
-                        sessionId: options.sessionId,
-                        requestId: options.requestId,
-                        agentId: currentAgentId,
-                        planState: finalPlanState,
-                    };
+                    for (const item of await emitPlanStateUpdate(options, currentAgentId, finalPlanState)) {
+                        yield item;
+                    }
                     const commentary = summarizePlanState(finalPlanState);
                     if (commentary) {
                         yield* emitCommentary(commentary);
                     }
                 }
             }
+            currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
+            const terminalStructuredStatus = readTerminalStructuredStatus(actual.structuredResponse);
+            if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
+                const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                const signature = buildPlanStateSignature(reconciledPlanState);
+                if (signature !== lastPlanStateSignature) {
+                    planStateVersion = reconciledPlanState.version;
+                    lastPlanStateSignature = signature;
+                    currentPlanState = reconciledPlanState;
+                    for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                        yield item;
+                    }
+                    const commentary = summarizePlanState(reconciledPlanState);
+                    if (commentary) {
+                        yield* emitCommentary(commentary);
+                    }
+                }
+            }
+        }
+        currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
+        if (assistantOutputCameFromInvokeFallback
+            && nonUpstreamStreamActivityObserved
+            && planStateHasActiveItems(currentPlanState)) {
+            throw new ExecutionReconciliationError("Agent ended while the streamed plan state still had unfinished work.");
+        }
+        if (planStateHasActiveItems(currentPlanState)) {
+            throw new ExecutionReconciliationError("Agent ended while the streamed plan state still had unfinished work.");
         }
         if (assistantOutput && bufferAssistantTextUntilCompletion) {
             yield {
@@ -686,13 +815,15 @@ export async function* streamHarnessRun(options) {
     catch (error) {
         const shouldRetryAfterStreamingCompatibilityError = !assistantOutput &&
             isOpenAICompatibleStreamingCompatibilityError(options.binding, error);
-        if ((emitted || streamActivityObserved) && !shouldRetryAfterStreamingCompatibilityError) {
+        if ((emitted || streamActivityObserved)
+            && !shouldRetryAfterStreamingCompatibilityError) {
             const runtimeFailure = renderRuntimeFailure(error);
+            const detailedError = describeRuntimeError(error);
             yield {
                 type: "event",
                 event: await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "failed", {
                     previousState: "running",
-                    error: error instanceof Error ? error.message : String(error),
+                    error: detailedError,
                 }),
             };
             yield {
@@ -717,11 +848,12 @@ export async function* streamHarnessRun(options) {
         }
         if (error instanceof RuntimeOperationTimeoutError && error.stage === "invoke") {
             const runtimeFailure = renderRuntimeFailure(error);
+            const detailedError = describeRuntimeError(error);
             yield {
                 type: "event",
                 event: await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "failed", {
                     previousState: "running",
-                    error: error.message,
+                    error: detailedError,
                 }),
             };
             yield {
@@ -744,6 +876,36 @@ export async function* streamHarnessRun(options) {
             };
             return;
         }
+        if (error instanceof ExecutionReconciliationError) {
+            const runtimeFailure = renderRuntimeFailure(error);
+            const detailedError = describeRuntimeError(error);
+            yield {
+                type: "event",
+                event: await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "failed", {
+                    previousState: "running",
+                    error: detailedError,
+                }),
+            };
+            yield {
+                type: "content",
+                sessionId: options.sessionId,
+                requestId: options.requestId,
+                agentId: options.selectedAgentId,
+                content: runtimeFailure,
+            };
+            yield {
+                type: "result",
+                result: {
+                    sessionId: options.sessionId,
+                    requestId: options.requestId,
+                    agentId: currentAgentId,
+                    state: "failed",
+                    output: runtimeFailure,
+                    finalMessageText: runtimeFailure,
+                },
+            };
+            return;
+        }
         try {
             syntheticFallback = {
                 strategy: "stream-to-invoke",
@@ -757,6 +919,19 @@ export async function* streamHarnessRun(options) {
             if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
                 yield createContentBlocksItem(options.sessionId, options.requestId, options.selectedAgentId, actual.contentBlocks);
             }
+            if (actual.output) {
+                yield {
+                    type: "event",
+                    event: await options.emit(options.sessionId, options.requestId, 3, "output.delta", { content: actual.output }),
+                };
+                yield {
+                    type: "content",
+                    sessionId: options.sessionId,
+                    requestId: options.requestId,
+                    agentId: currentAgentId,
+                    content: actual.output,
+                };
+            }
             const terminalEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, actual.state, {
                 previousState: "running",
             });
@@ -798,11 +973,12 @@ export async function* streamHarnessRun(options) {
             };
             await options.emitSyntheticFallback(options.sessionId, options.requestId, options.selectedAgentId, syntheticFallback);
             const runtimeFailure = renderRuntimeFailure(invokeError);
+            const detailedError = describeRuntimeError(invokeError);
             yield {
                 type: "event",
                 event: await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "failed", {
                     previousState: "running",
-                    error: invokeError instanceof Error ? invokeError.message : String(invokeError),
+                    error: detailedError,
                 }),
             };
             yield {

package/dist/runtime/harness.js

@@ -215,6 +215,7 @@ export class AgentHarnessRuntime {
             runtimeAdapterOptions: {
                 ...runtimeAdapterOptions,
                 scheduleManager: runtimeAdapterOptions.scheduleManager ?? this.scheduleManager,
+                bindingResolver: runtimeAdapterOptions.bindingResolver ?? ((agentId) => this.workspace.bindings.get(agentId)),
                 functionToolContextResolver: runtimeAdapterOptions.functionToolContextResolver ?? ((input) => this.buildFunctionToolContext(input)),
             },
             checkpointers: this.checkpointers,
@@ -1303,6 +1304,8 @@ export class AgentHarnessRuntime {
             clearRequestInput: (sessionId, requestId) => this.persistence.clearRequestInput(sessionId, requestId),
             updateRequestInspection: (sessionId, requestId, patch) => this.persistence.updateRequestInspection(sessionId, requestId, patch),
             appendRequestTraceItem: (sessionId, requestId, item) => this.persistence.appendRequestTraceItem(sessionId, requestId, item),
+            loadRequestPlanState: (sessionId, requestId) => this.persistence.getRequestPlanState(sessionId, requestId),
+            saveRequestPlanState: (sessionId, requestId, planState) => this.persistence.saveRequestPlanState(sessionId, requestId, planState),
             emitSyntheticFallback: (sessionId, requestId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(sessionId, requestId, selectedAgentId, error),
         });
         for await (const item of stream) {

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

@@ -1,5 +1,5 @@
 import { AIMessage } from "langchain";
-import { salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
+import { salvageFunctionLikeToolCall, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
 export function sanitizeVisibleText(value) {
     return value
         .replace(/[A-Za-z0-9_]*Middleware\.after_model/g, "")
@@ -403,19 +403,26 @@ function normalizeAgentMessage(value) {
         })
             .filter((toolCall) => toolCall !== null)
         : [];
-    const recoveredToolCalls = normalizedInvalidToolCalls.filter((toolCall) => typeof toolCall.args === "object" && !!toolCall.args && !Array.isArray(toolCall.args));
     const normalizedContent = typeof typed.content === "string" || Array.isArray(typed.content)
         ? typed.content
         : typeof typed.content === "object" && typed.content
             ? readTextContent(typed.content)
             : "";
+    const recoveredToolCalls = normalizedInvalidToolCalls.filter((toolCall) => typeof toolCall.args === "object" && !!toolCall.args && !Array.isArray(toolCall.args));
+    const functionLikeToolCall = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && typeof normalizedContent === "string"
+        ? salvageFunctionLikeToolCall(normalizedContent)
+        : null;
     return new AIMessage({
-        content: normalizedContent,
+        content: functionLikeToolCall ? "" : normalizedContent,
         name: typeof typed.name === "string" ? typed.name : undefined,
         additional_kwargs: typeof typed.additional_kwargs === "object" && typed.additional_kwargs ? typed.additional_kwargs : {},
         response_metadata: typeof typed.response_metadata === "object" && typed.response_metadata ? typed.response_metadata : {},
         id: typeof typed.id === "string" ? typed.id : undefined,
-        tool_calls: [...normalizedToolCalls, ...recoveredToolCalls],
+        tool_calls: [
+            ...normalizedToolCalls,
+            ...recoveredToolCalls,
+            ...(functionLikeToolCall ? [{ name: functionLikeToolCall.name, args: functionLikeToolCall.args }] : []),
+        ],
         invalid_tool_calls: normalizedInvalidToolCalls.filter((toolCall) => toolCall.type !== "tool_call"),
         usage_metadata: typeof typed.usage_metadata === "object" && typed.usage_metadata ? typed.usage_metadata : undefined,
     });

package/dist/runtime/parsing/output-recovery.d.ts

@@ -11,6 +11,9 @@ export declare function resolveExecutionWithoutToolEvidenceInstruction(request:
 export declare function resolveExecutionWithoutToolEvidenceTextInstruction(request: unknown, assistantText: string, toolCallEvidence?: boolean, resultEvidence?: {
     hasWriteTodosEvidence?: boolean;
     hasToolResultEvidence?: boolean;
+    hasIncompletePlanState?: boolean;
+    hasOpenTaskDelegation?: boolean;
+    hasMissingDelegatedExecutionEvidence?: boolean;
 }): string | null;
 export declare function resolveToolCallRecoveryInstruction(error: unknown): string | null;
 export declare function appendToolRecoveryInstruction(input: unknown, instruction: string): unknown;