@botbotgo/agent-harness 0.0.326 → 0.0.328

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

@@ -1,4 +1,4 @@
-import { HumanMessage } from "@langchain/core/messages";
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware } from "langchain";
 import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
@@ -7,9 +7,98 @@ import { extractToolFallbackContext, extractVisibleOutput } from "../parsing/out
 import { isRecord } from "../../utils/object.js";
 import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
-import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
-import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
+import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingDeepAgentSubagents, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
+import { materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
 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";
+const EMPTY_TOOL_NAME_MAPPING = {
+    originalToModelFacing: new Map(),
+    modelFacingToOriginal: new Map(),
+};
+function readPlanStateSummaryCounts(summary) {
+    if (typeof summary !== "object" || summary === null) {
+        return null;
+    }
+    const typed = summary;
+    const hasAny = typeof typed.pending === "number"
+        || typeof typed.inProgress === "number";
+    if (!hasAny) {
+        return null;
+    }
+    return {
+        pending: typeof typed.pending === "number" ? typed.pending : 0,
+        inProgress: typeof typed.inProgress === "number" ? typed.inProgress : 0,
+    };
+}
+function hasIncompletePlanTodos(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.some((item) => {
+        if (typeof item !== "object" || item === null) {
+            return false;
+        }
+        const status = item.status;
+        return status === "pending" || status === "in_progress";
+    });
+}
+function hasIncompletePlanStateInValue(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => hasIncompletePlanStateInValue(item));
+    }
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const typed = value;
+    const summaryCounts = readPlanStateSummaryCounts(typed.summary);
+    if (summaryCounts) {
+        return summaryCounts.pending > 0 || summaryCounts.inProgress > 0;
+    }
+    const todoCompleteness = hasIncompletePlanTodos(typed.todos);
+    if (todoCompleteness !== null) {
+        return todoCompleteness;
+    }
+    const nestedCandidates = [
+        typed.summary,
+        typed.output,
+        typed.content,
+        typed.update,
+        typed.data,
+        typed.messages,
+    ];
+    return nestedCandidates.some((candidate) => hasIncompletePlanStateInValue(candidate));
+}
+function hasUnresolvedDelegatedExecution(state) {
+    return state.hasIncompletePlanState || state.openTaskDelegations > 0;
+}
+function hasMissingDelegatedToolExecutionEvidence(state, subagentHasTools) {
+    return subagentHasTools && !state.emittedToolResult && !state.emittedToolError;
+}
+function formatDelegatedExecutionBlocker(state) {
+    const summary = state.emittedOutput.trim();
+    if (summary) {
+        return summary;
+    }
+    if (state.emittedToolError) {
+        return "Delegated investigation encountered a tool failure before the plan completed.";
+    }
+    if (state.openTaskDelegations > 0) {
+        return "Delegated investigation did not finish before control returned to the parent agent.";
+    }
+    return "Delegated investigation ended before the plan was completed.";
+}
+function requiresDelegatedExecutionRecovery(state) {
+    return hasUnresolvedDelegatedExecution(state) || (state.emittedToolResult && !state.emittedOutput.trim());
+}
+const DELEGATED_FAILURE_PLAN_RECONCILIATION_INSTRUCTION = [
+    "Your previous attempt ended with a tool failure while the todo board still had unfinished work.",
+    "Do not continue broad investigation from here.",
+    "If the failed command had malformed arguments you can correct locally, retry that same command once.",
+    "Otherwise, if a todo board already exists, call write_todos again and keep only the tasks that were actually completed in this session.",
+    "Remove the unfinished tasks that cannot proceed until the blocker is resolved.",
+    "Then return a concise blocker report.",
+].join(" ");
 export function buildBuiltinTaskSubagentMiddleware(input) {
     const { selectedSubagent, builtinBackend, summarizationModel } = input;
     const defaultSubagentMiddleware = [
@@ -57,13 +146,6 @@ function buildLangChainContextMiddleware(params) {
     }
     return middleware;
 }
-function resolveLangChainDelegationCompatibility(params) {
-    return applyDeepAgentDelegationPromptCompatibility(params.model, {
-        subagents: params.subagents,
-        generalPurposeAgent: params.generalPurposeAgent,
-        taskDescription: params.taskDescription,
-    });
-}
 export function planLangChainRuntimeExtensions(binding) {
     const primaryModel = getBindingPrimaryModel(binding);
     if (!isLangChainBinding(binding) || !primaryModel) {
@@ -71,12 +153,6 @@ export function planLangChainRuntimeExtensions(binding) {
     }
     const skills = getBindingSkills(binding);
     const memory = getBindingMemorySources(binding);
-    const delegationCompatibility = resolveLangChainDelegationCompatibility({
-        model: primaryModel,
-        subagents: getBindingSubagents(binding),
-        generalPurposeAgent: getBindingGeneralPurposeAgent(binding),
-        taskDescription: getBindingTaskDescription(binding),
-    });
     return {
         includePatchToolCalls: !bindingHasMiddlewareKind(binding, "patchToolCalls"),
         includeAutomaticSummarization: !bindingHasMiddlewareKind(binding, "summarization"),
@@ -86,9 +162,9 @@ export function planLangChainRuntimeExtensions(binding) {
         },
         delegation: bindingHasLangChainSubagentSupport(binding)
             ? {
-                subagents: delegationCompatibility.subagents ?? [],
-                generalPurposeAgent: delegationCompatibility.generalPurposeAgent,
-                taskDescription: delegationCompatibility.taskDescription,
+                subagents: getBindingSubagents(binding),
+                generalPurposeAgent: getBindingGeneralPurposeAgent(binding),
+                taskDescription: getBindingTaskDescription(binding),
                 interruptOn: getBindingInterruptCompatibilityRules(binding),
             }
             : undefined,
@@ -142,13 +218,18 @@ export async function invokeBuiltinTaskTool(input) {
     }
     const primaryModel = getBindingPrimaryModel(input.binding);
     const primaryTools = getBindingPrimaryTools(input.binding);
-    const compiledSubagents = getBindingSubagents(input.binding);
+    const compiledSubagents = getBindingDeepAgentSubagents(input.binding)
+        .filter((subagent) => !("graphId" in subagent));
     if (!primaryModel) {
         throw new Error(`Agent ${input.binding.agent.id} has no deepagent params`);
     }
     const typedInput = isRecord(input.toolInput) ? input.toolInput : {};
-    const description = typeof typedInput.description === "string" ? typedInput.description : "";
-    const subagentType = typeof typedInput.subagent_type === "string" ? typedInput.subagent_type : "";
+    const description = typeof typedInput.description === "string"
+        ? typedInput.description
+        : "";
+    const subagentType = typeof typedInput.subagent_type === "string"
+        ? typedInput.subagent_type
+        : "";
     const builtinBackend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
     const resolvedSubagents = await input.resolveSubagents(compiledSubagents, input.binding);
     const selectedSubagent = resolvedSubagents.find((subagent) => subagent.name === subagentType);
@@ -163,16 +244,82 @@ export async function invokeBuiltinTaskTool(input) {
         builtinBackend,
         summarizationModel,
     });
+    const resolvedSubagentTools = selectedSubagent.tools ?? input.resolveTools(primaryTools, input.binding);
+    const subagentHasTools = (resolvedSubagentTools?.length ?? 0) > 0;
     const runnable = createAgent({
         model: (selectedSubagent.model ?? resolvedHostModel),
-        tools: (selectedSubagent.tools ?? input.resolveTools(primaryTools, input.binding)),
+        tools: resolvedSubagentTools,
         systemPrompt: selectedSubagent.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
         middleware: middleware,
         responseFormat: selectedSubagent.responseFormat,
         name: selectedSubagent.name,
         description: selectedSubagent.description,
     });
-    const result = await runnable.invoke({ messages: [new HumanMessage({ content: description })] }, { configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: `${input.binding.agent.id}:builtin-task` }, ...(input.options?.context ? { context: input.options.context } : {}) });
+    const invokeConfig = {
+        configurable: { [UPSTREAM_SESSION_CONFIG_KEY]: `${input.binding.agent.id}:builtin-task` },
+        ...(input.options?.context ? { context: input.options.context } : {}),
+    };
+    const buildMessages = (recoveryInstruction) => ({
+        messages: [
+            ...(recoveryInstruction ? [new SystemMessage({ content: recoveryInstruction })] : []),
+            new HumanMessage({ content: description }),
+        ],
+    });
+    if (typeof runnable.streamEvents === "function") {
+        const runWithStreamInspection = async (recoveryInstruction) => {
+            const projectionState = createStreamEventProjectionState();
+            const events = await runnable.streamEvents(buildMessages(recoveryInstruction), invokeConfig);
+            for await (const event of events) {
+                projectRuntimeStreamEvent({
+                    event,
+                    allowVisibleStreamDeltas: false,
+                    includeStateStreamOutput: false,
+                    rootAgentId: input.binding.agent.id,
+                    countConfiguredToolsForAgentId: (agentId) => agentId === selectedSubagent.name ? resolvedSubagentTools.length : 0,
+                    toolNameMapping: EMPTY_TOOL_NAME_MAPPING,
+                    primaryTools: [],
+                    state: projectionState,
+                });
+            }
+            return projectionState;
+        };
+        let projectionState = 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);
+        }
+        if (requiresDelegatedExecutionRecovery(projectionState)) {
+            throw new Error(formatDelegatedExecutionBlocker(projectionState));
+        }
+        if (hasMissingDelegatedToolExecutionEvidence(projectionState, subagentHasTools)) {
+            throw new Error("Delegated investigation ended without any real tool execution evidence.");
+        }
+        if (projectionState.emittedToolError) {
+            const blockerMessage = projectionState.emittedOutput.trim()
+                || formatDelegatedExecutionBlocker(projectionState);
+            if (hasUnresolvedDelegatedExecution(projectionState) || !projectionState.emittedSuccessfulToolResult) {
+                throw new Error(blockerMessage);
+            }
+        }
+        if (projectionState.emittedOutput.trim()) {
+            return projectionState.emittedOutput.trim();
+        }
+        if (projectionState.emittedToolResult) {
+            throw new Error("Delegated investigation performed tool work but did not return surfaced findings.");
+        }
+    }
+    let result = await runnable.invoke(buildMessages(), invokeConfig);
+    if (hasIncompletePlanStateInValue(result)) {
+        result = await runnable.invoke(buildMessages(AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION), invokeConfig);
+    }
+    if (hasIncompletePlanStateInValue(result)) {
+        throw new Error(extractVisibleOutput(result) || extractToolFallbackContext(result) || "Delegated investigation ended before the plan was completed.");
+    }
+    if (subagentHasTools) {
+        throw new Error("Delegated investigation ended without any real tool execution evidence.");
+    }
     const visibleOutput = extractVisibleOutput(result);
     const fallbackOutput = extractToolFallbackContext(result);
     return visibleOutput || fallbackOutput || JSON.stringify(result);
@@ -180,12 +327,10 @@ export async function invokeBuiltinTaskTool(input) {
 export async function resolveBuiltinMiddlewareTools(input) {
     const backend = input.resolveBuiltinMiddlewareBackend(input.binding, input.options);
     return createBuiltinMiddlewareTools(backend, {
-        includeTaskTool: isDeepAgentBinding(input.binding),
+        includeTaskTool: false,
         workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
         toolRuntimeContext: input.options?.toolRuntimeContext,
-        invokeTaskTool: isDeepAgentBinding(input.binding)
-            ? async (toolInput) => input.invokeBuiltinTaskTool(input.binding, toolInput, input.options)
-            : undefined,
+        invokeTaskTool: undefined,
     });
 }
 export async function materializeAutomaticSummarizationMiddleware(input) {
@@ -214,7 +359,7 @@ export async function materializeLangChainRuntimeMiddleware(input) {
         memory: input.plan.context.memory,
         resolveFilesystemBackend: input.resolveFilesystemBackend,
     }));
-    if (input.plan.delegation) {
+    if (input.plan.delegation && !isDeepAgentBinding(input.binding)) {
         runtimeMiddleware.push(createSubAgentMiddleware({
             defaultModel: (await input.resolveModel(primaryModel)),
             defaultTools: input.resolveTools(primaryTools, input.binding),

package/dist/runtime/adapter/runtime-adapter-support.js

@@ -37,7 +37,6 @@ export function summarizeBuiltinWriteTodosArgs(args) {
         completed: items.filter((item) => item.status === "completed").length,
         failed: items.filter((item) => item.status === "failed").length,
         cancelled: items.filter((item) => item.status === "cancelled").length,
-        blocked: items.filter((item) => item.status === "blocked").length,
     };
     return {
         items,
@@ -56,7 +55,7 @@ export function formatBuiltinTodoSnapshot(snapshot) {
         return "No todos tracked.";
     }
     const lines = [
-        `Tracked ${snapshot.summary.total} todo item(s): ${snapshot.summary.pending + snapshot.summary.inProgress + snapshot.summary.blocked} pending, ${snapshot.summary.completed} completed.`,
+        `Tracked ${snapshot.summary.total} todo item(s): ${snapshot.summary.pending + snapshot.summary.inProgress} pending, ${snapshot.summary.completed} completed.`,
         ...snapshot.items.map((item, index) => `${index + 1}. [${item.status}] ${item.content}`),
     ];
     return truncateLines(lines);

package/dist/runtime/adapter/stream-event-projection.d.ts

@@ -5,6 +5,21 @@ export type StreamEventProjectionState = {
     emittedOutput: string;
     emittedToolError: boolean;
     emittedToolResult: boolean;
+    emittedSuccessfulToolResult: boolean;
+    emittedSuccessfulTaskResult: boolean;
+    emittedPlaceholderTaskResult: boolean;
+    hasFailedTaskDelegation: boolean;
+    emittedNonTodoToolResult: boolean;
+    emittedSuccessfulNonTodoToolResult: boolean;
+    sawDelegatedAgentWithConfiguredTools: boolean;
+    emittedDelegatedExecutionToolResult: boolean;
+    emittedSuccessfulDelegatedExecutionToolResult: boolean;
+    emittedDelegatedTerminalOutput: boolean;
+    sawPlanState: boolean;
+    hasIncompletePlanState: boolean;
+    openTaskDelegations: number;
+    openToolCapableTaskDelegations: number;
+    taskDelegationHasToolsStack: boolean[];
     seenTerminalOutputs: Set<string>;
 };
 export declare function createStreamEventProjectionState(): StreamEventProjectionState;
@@ -12,6 +27,8 @@ export declare function projectRuntimeStreamEvent(params: {
     event: unknown;
     allowVisibleStreamDeltas: boolean;
     includeStateStreamOutput: boolean;
+    rootAgentId?: string;
+    countConfiguredToolsForAgentId?: (agentId: string) => number;
     toolNameMapping: ToolNameMapping;
     primaryTools: CompiledTool[];
     state: StreamEventProjectionState;

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

@@ -6,15 +6,190 @@ export function createStreamEventProjectionState() {
         emittedOutput: "",
         emittedToolError: false,
         emittedToolResult: false,
+        emittedSuccessfulToolResult: false,
+        emittedSuccessfulTaskResult: false,
+        emittedPlaceholderTaskResult: false,
+        hasFailedTaskDelegation: false,
+        emittedNonTodoToolResult: false,
+        emittedSuccessfulNonTodoToolResult: false,
+        sawDelegatedAgentWithConfiguredTools: false,
+        emittedDelegatedExecutionToolResult: false,
+        emittedSuccessfulDelegatedExecutionToolResult: false,
+        emittedDelegatedTerminalOutput: false,
+        sawPlanState: false,
+        hasIncompletePlanState: false,
+        openTaskDelegations: 0,
+        openToolCapableTaskDelegations: 0,
+        taskDelegationHasToolsStack: [],
         seenTerminalOutputs: new Set(),
     };
 }
+function readSummaryCounts(summary) {
+    if (typeof summary !== "object" || summary === null) {
+        return null;
+    }
+    const typed = summary;
+    const hasAnyCountField = typeof typed.pending === "number"
+        || typeof typed.inProgress === "number";
+    if (!hasAnyCountField) {
+        return null;
+    }
+    return {
+        pending: typeof typed.pending === "number" ? typed.pending : 0,
+        inProgress: typeof typed.inProgress === "number" ? typed.inProgress : 0,
+    };
+}
+function hasIncompleteTodosArray(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    return value.some((item) => {
+        if (typeof item !== "object" || item === null) {
+            return false;
+        }
+        const status = item.status;
+        return status === "pending" || status === "in_progress";
+    });
+}
+function getPlanStateCompleteness(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const typed = value;
+    const summaryCounts = readSummaryCounts(typed.summary);
+    if (summaryCounts) {
+        return summaryCounts.pending > 0 || summaryCounts.inProgress > 0;
+    }
+    if (typeof typed.summary === "object" && typed.summary !== null) {
+        const nestedSummary = getPlanStateCompleteness(typed.summary);
+        if (nestedSummary !== null) {
+            return nestedSummary;
+        }
+    }
+    const directTodos = hasIncompleteTodosArray(typed.todos);
+    if (directTodos !== null) {
+        return directTodos;
+    }
+    if (typeof typed.update === "object" && typed.update !== null) {
+        const nestedTodos = hasIncompleteTodosArray(typed.update.todos);
+        if (nestedTodos !== null) {
+            return nestedTodos;
+        }
+    }
+    if (typeof typed.output === "object" && typed.output !== null) {
+        const nestedOutput = getPlanStateCompleteness(typed.output);
+        if (nestedOutput !== null) {
+            return nestedOutput;
+        }
+    }
+    if (typeof typed.data === "object" && typed.data !== null) {
+        const nestedData = getPlanStateCompleteness(typed.data);
+        if (nestedData !== null) {
+            return nestedData;
+        }
+    }
+    return null;
+}
+function parseMaybeJsonString(value) {
+    const trimmed = value.trim();
+    if (!trimmed || (!trimmed.startsWith("{") && !trimmed.startsWith("["))) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function unwrapPossibleToolInput(value) {
+    if (typeof value === "string") {
+        return parseMaybeJsonString(value);
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return value;
+    }
+    const typed = value;
+    if (typed.args !== undefined) {
+        return unwrapPossibleToolInput(typed.args);
+    }
+    if (typed.input !== undefined) {
+        return unwrapPossibleToolInput(typed.input);
+    }
+    return value;
+}
+function readTaskSubagentType(value) {
+    const unwrapped = unwrapPossibleToolInput(value);
+    if (typeof unwrapped !== "object" || unwrapped === null || Array.isArray(unwrapped)) {
+        return null;
+    }
+    const typed = unwrapped;
+    return typeof typed.subagent_type === "string" && typed.subagent_type.trim().length > 0
+        ? typed.subagent_type.trim()
+        : null;
+}
+function isUpstreamPlaceholderTaskResult(value) {
+    if (typeof value === "string") {
+        return value.trim() === "Task completed";
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const typed = value;
+    const messages = Array.isArray(typed.update?.messages) ? typed.update.messages : [];
+    if (messages.length !== 1) {
+        return false;
+    }
+    const message = messages[0];
+    return typed.lg_name === "Command"
+        && typed.lc_direct_tool_output === true
+        && message?.name === "task"
+        && message?.type === "tool"
+        && typeof message?.tool_call_id === "string"
+        && message?.content === "Task completed";
+}
+function updateDelegationState(state, event, countConfiguredToolsForAgentId) {
+    if (typeof event !== "object" || event === null) {
+        return;
+    }
+    const typed = event;
+    const eventName = typeof typed.event === "string" ? typed.event : "";
+    const toolName = typeof typed.name === "string" ? typed.name : "";
+    const runType = typeof typed.run_type === "string" ? typed.run_type : "";
+    const isTaskStart = toolName === "task" && (eventName === "on_tool_start" || (eventName === "on_chain_start" && runType === "tool"));
+    const isTaskEnd = toolName === "task" && (eventName === "on_tool_end" || (eventName === "on_chain_end" && runType === "tool"));
+    const isTaskError = toolName === "task" && (eventName === "on_tool_error" || (eventName === "on_chain_error" && runType === "tool"));
+    if (isTaskStart) {
+        state.openTaskDelegations += 1;
+        const delegatedSubagentType = readTaskSubagentType(typed.data?.input);
+        const delegatedTaskHasTools = !!delegatedSubagentType
+            && !!countConfiguredToolsForAgentId
+            && countConfiguredToolsForAgentId(delegatedSubagentType) > 0;
+        state.taskDelegationHasToolsStack.push(delegatedTaskHasTools);
+        if (delegatedTaskHasTools) {
+            state.sawDelegatedAgentWithConfiguredTools = true;
+            state.openToolCapableTaskDelegations += 1;
+        }
+        return;
+    }
+    if (isTaskEnd || isTaskError) {
+        state.openTaskDelegations = Math.max(0, state.openTaskDelegations - 1);
+        const delegatedTaskHadTools = state.taskDelegationHasToolsStack.pop() === true;
+        if (delegatedTaskHadTools) {
+            state.openToolCapableTaskDelegations = Math.max(0, state.openToolCapableTaskDelegations - 1);
+        }
+        if (isTaskError) {
+            state.hasFailedTaskDelegation = true;
+        }
+    }
+}
 export function projectRuntimeStreamEvent(params) {
-    const { event, allowVisibleStreamDeltas, includeStateStreamOutput, toolNameMapping, primaryTools, state, } = params;
+    const { event, allowVisibleStreamDeltas, includeStateStreamOutput, rootAgentId, countConfiguredToolsForAgentId, toolNameMapping, primaryTools, state, } = params;
     const chunks = [{
             kind: "upstream-event",
             event: sanitizeRetainedUpstreamEvent(event),
         }];
+    updateDelegationState(state, event, countConfiguredToolsForAgentId);
     const interruptPayload = extractInterruptPayload(event);
     if (interruptPayload) {
         chunks.push({ kind: "interrupt", content: interruptPayload });
@@ -24,7 +199,24 @@ export function projectRuntimeStreamEvent(params) {
     if (reasoning) {
         chunks.push({ kind: "reasoning", content: reasoning });
     }
-    if (allowVisibleStreamDeltas) {
+    const planStateCompleteness = getPlanStateCompleteness(event);
+    if (planStateCompleteness !== null) {
+        state.sawPlanState = true;
+        state.hasIncompletePlanState = planStateCompleteness;
+    }
+    const eventAgentId = typeof event === "object" && event !== null && typeof event.agentId === "string"
+        ? event.agentId.trim()
+        : "";
+    const isDelegatedAgentEvent = !!rootAgentId && !!eventAgentId && eventAgentId !== rootAgentId;
+    if (isDelegatedAgentEvent
+        && countConfiguredToolsForAgentId
+        && countConfiguredToolsForAgentId(eventAgentId) > 0) {
+        state.sawDelegatedAgentWithConfiguredTools = true;
+    }
+    const isRootVisibleEvent = !rootAgentId || !eventAgentId || eventAgentId === rootAgentId;
+    const allowVisibleContent = isRootVisibleEvent && state.openTaskDelegations === 0;
+    const allowStreamedVisibleContent = allowVisibleContent && !state.emittedToolResult && !state.emittedToolError;
+    if (allowVisibleStreamDeltas && allowStreamedVisibleContent) {
         const visibleStreamOutput = extractVisibleStreamOutput(event);
         if (visibleStreamOutput) {
             const nextOutput = computeIncrementalOutput(state.emittedOutput, visibleStreamOutput);
@@ -34,7 +226,7 @@ export function projectRuntimeStreamEvent(params) {
             }
         }
     }
-    if (includeStateStreamOutput) {
+    if (includeStateStreamOutput && allowVisibleContent) {
         const stateStreamOutput = extractStateStreamOutput(event);
         if (stateStreamOutput) {
             const nextOutput = computeIncrementalOutput(state.emittedOutput, sanitizeVisibleText(stateStreamOutput));
@@ -46,8 +238,23 @@ export function projectRuntimeStreamEvent(params) {
     }
     const toolResult = extractToolResult(event);
     if (toolResult) {
+        const isTodoTool = toolResult.toolName === "write_todos" || toolResult.toolName === "read_todos";
+        const isSuccessfulTaskResult = toolResult.toolName === "task" && toolResult.isError !== true;
+        const isPlaceholderTaskResult = isSuccessfulTaskResult && isUpstreamPlaceholderTaskResult(toolResult.output);
+        const isDelegatedExecutionTool = (isDelegatedAgentEvent || state.openToolCapableTaskDelegations > 0)
+            && toolResult.toolName !== "write_todos"
+            && toolResult.toolName !== "read_todos"
+            && toolResult.toolName !== "task";
         state.emittedToolResult = true;
         state.emittedToolError = state.emittedToolError || toolResult.isError === true;
+        state.emittedSuccessfulToolResult = state.emittedSuccessfulToolResult || toolResult.isError !== true;
+        state.emittedSuccessfulTaskResult = state.emittedSuccessfulTaskResult || isSuccessfulTaskResult;
+        state.emittedPlaceholderTaskResult = state.emittedPlaceholderTaskResult || isPlaceholderTaskResult;
+        state.emittedNonTodoToolResult = state.emittedNonTodoToolResult || !isTodoTool;
+        state.emittedSuccessfulNonTodoToolResult = state.emittedSuccessfulNonTodoToolResult || (!isTodoTool && toolResult.isError !== true);
+        state.emittedDelegatedExecutionToolResult = state.emittedDelegatedExecutionToolResult || isDelegatedExecutionTool;
+        state.emittedSuccessfulDelegatedExecutionToolResult =
+            state.emittedSuccessfulDelegatedExecutionToolResult || (isDelegatedExecutionTool && toolResult.isError !== true);
         chunks.push({
             kind: "tool-result",
             toolName: resolveModelFacingToolName(toolResult.toolName, toolNameMapping, primaryTools),
@@ -55,7 +262,13 @@ export function projectRuntimeStreamEvent(params) {
             isError: toolResult.isError,
         });
     }
-    const output = extractTerminalStreamOutput(event);
+    const output = allowVisibleContent ? extractTerminalStreamOutput(event) : "";
+    if (!allowVisibleContent) {
+        const delegatedTerminalOutput = extractTerminalStreamOutput(event);
+        if (delegatedTerminalOutput) {
+            state.emittedDelegatedTerminalOutput = true;
+        }
+    }
     if (output) {
         const outputKey = normalizeTerminalOutputKey(output);
         if (!outputKey || !state.seenTerminalOutputs.has(outputKey)) {

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -242,9 +242,6 @@ export declare const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS: readonly [{
 }, {
     readonly name: "task";
     readonly description: "Delegate a bounded task to a subagent.";
-}, {
-    readonly name: "delegate_task";
-    readonly description: "Delegate a bounded task to a subagent.";
 }];
 export declare function createBuiltinMiddlewareTools(backend: BuiltinMiddlewareBackend, options: {
     includeTaskTool: boolean;