@botbotgo/agent-harness 0.0.338 → 0.0.341

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -1,6 +1,6 @@
 import type { CompiledAgentBinding, MessageContent, RequestResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
-import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn } from "./agent-runtime-assembly.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn } from "./agent-runtime-assembly.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
 export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
@@ -45,6 +45,7 @@ export declare class AgentRuntimeAdapter {
     private createLangChainRunnable;
     private createRunnable;
     private createDeepAgentRunnable;
+    private createConfigurableDeepAgentRunnable;
     private buildRunnableCacheKey;
     create(binding: CompiledAgentBinding, options?: {
         sessionId?: string;
@@ -66,4 +67,4 @@ export declare class AgentRuntimeAdapter {
         toolRuntimeContext?: Record<string, unknown>;
     }): AsyncGenerator<RuntimeStreamChunk | string>;
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };

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

@@ -1,25 +1,29 @@
 import path from "node:path";
-import { createDeepAgent, FilesystemBackend, } from "deepagents";
-import { createAgent } from "langchain";
+import { GENERAL_PURPOSE_SUBAGENT, createAsyncSubAgentMiddleware, createDeepAgent, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
+import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
 import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { applyToolRecoveryInstruction as applyToolRecoveryInstructionHelper, applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
-import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
+import { extractSubagentRequestText, invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, wrapRequestResultAsSubagentResponse, } from "./adapter/middleware-assembly.js";
 import { resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { renderDirectWorkspaceListing, shouldDirectlyListWorkspaceFiles } from "./adapter/direct-builtin-utility.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
+import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
 export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingAdapterKind, getBindingDeepAgentSubagents, getBindingExecutionKind, getBindingFilesystemConfig, getBindingPrimaryModel, getBindingSkills, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+function shouldUseConfigurableDeepAgentAssembly(binding) {
+    return getBindingBuiltinToolsConfig(binding) !== undefined;
+}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -279,13 +283,64 @@ export class AgentRuntimeAdapter {
             resolveModel: assembly.resolveModel,
             resolveTools: assembly.resolveTools,
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
+            resolveBackend: (currentBinding) => {
+                const targetBinding = currentBinding ?? binding;
+                return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
+            },
         });
     }
-    async resolveDeepAgentSubagents(subagents, binding) {
+    async resolveDeepAgentSubagents(subagents, binding, options = {}) {
         const syncSubagents = subagents.filter((subagent) => !("graphId" in subagent));
         const asyncSubagents = subagents.filter((subagent) => "graphId" in subagent);
         const resolvedSyncSubagents = await this.resolveSubagents(syncSubagents, binding);
-        return [...resolvedSyncSubagents, ...asyncSubagents];
+        const wrappedSyncSubagents = await Promise.all(resolvedSyncSubagents.map(async (resolvedSubagent, index) => {
+            const compiledSubagent = syncSubagents[index];
+            const targetAgentId = compiledSubagent?.agentId;
+            const targetBinding = targetAgentId ? this.options.bindingResolver?.(targetAgentId) : undefined;
+            if (!targetBinding) {
+                return resolvedSubagent;
+            }
+            const wrapper = {
+                name: resolvedSubagent.name,
+                description: resolvedSubagent.description,
+                systemPrompt: resolvedSubagent.systemPrompt,
+                runnable: {
+                    invoke: async (state, config) => {
+                        const requestText = extractSubagentRequestText(state);
+                        const configurable = typeof config?.configurable === "object" && config.configurable
+                            ? config.configurable
+                            : {};
+                        const sessionId = typeof configurable[UPSTREAM_SESSION_CONFIG_KEY] === "string"
+                            ? configurable[UPSTREAM_SESSION_CONFIG_KEY]
+                            : options.sessionId ?? `${binding?.agent.id ?? "agent"}:${resolvedSubagent.name}`;
+                        const requestId = typeof configurable[UPSTREAM_REQUEST_CONFIG_KEY] === "string"
+                            ? configurable[UPSTREAM_REQUEST_CONFIG_KEY]
+                            : sessionId;
+                        const childSessionId = `${sessionId}:delegated:${resolvedSubagent.name}`;
+                        const childRequestId = `${requestId}:delegated:${resolvedSubagent.name}:${Date.now().toString(36)}`;
+                        try {
+                            const result = await this.invoke(targetBinding, requestText, childSessionId, childRequestId, undefined, [], {
+                                ...(typeof config?.context === "object" && config.context ? { context: config.context } : {}),
+                            });
+                            return wrapRequestResultAsSubagentResponse({
+                                output: result.output,
+                                structuredResponse: result.structuredResponse,
+                            });
+                        }
+                        catch (error) {
+                            const message = error instanceof Error && error.message.trim().length > 0
+                                ? error.message.trim()
+                                : "delegated execution failed";
+                            return wrapRequestResultAsSubagentResponse({
+                                output: `Blocked: ${message}`,
+                            });
+                        }
+                    },
+                },
+            };
+            return wrapper;
+        }));
+        return [...wrappedSyncSubagents, ...asyncSubagents];
     }
     async createLangChainRunnable(binding, options = {}) {
         const executionKind = getBindingExecutionKind(binding);
@@ -352,7 +407,7 @@ export class AgentRuntimeAdapter {
             explicitToolNames: primaryTools.map((tool) => tool.name),
         });
         const resolvedMiddleware = await this.resolveMiddleware(binding);
-        const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding);
+        const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding, { sessionId: options.sessionId ?? options.legacySessionId });
         const resolvedInterruptOn = resolveRunnableInterruptOn(binding);
         const resolvedCheckpointer = shouldAttachDeepAgentCheckpointer(binding, resolvedInterruptOn)
             ? resolveRunnableCheckpointer(this.options, binding)
@@ -377,8 +432,66 @@ export class AgentRuntimeAdapter {
             resolvedInterruptOn,
             resolvedSkills,
         });
+        if (shouldUseConfigurableDeepAgentAssembly(binding)) {
+            return this.createConfigurableDeepAgentRunnable(binding, {
+                resolvedModel,
+                resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
+                resolvedMiddleware,
+                resolvedSubagents,
+                resolvedInterruptOn,
+                resolvedBackend,
+                resolvedSkills,
+            });
+        }
         return createDeepAgent(deepAgentConfig);
     }
+    createConfigurableDeepAgentRunnable(binding, input) {
+        const builtinTools = getBindingBuiltinToolsConfig(binding) ?? {};
+        const backend = (input.resolvedBackend ?? new StateBackend({}));
+        const inlineSubagents = input.resolvedSubagents.filter((subagent) => !("graphId" in subagent));
+        const asyncSubagents = input.resolvedSubagents.filter((subagent) => "graphId" in subagent);
+        const subagents = inlineSubagents.some((subagent) => subagent.name === GENERAL_PURPOSE_SUBAGENT.name)
+            ? inlineSubagents
+            : [{
+                    ...GENERAL_PURPOSE_SUBAGENT,
+                    model: input.resolvedModel,
+                    tools: input.resolvedTools,
+                    skills: input.resolvedSkills,
+                }, ...inlineSubagents];
+        const middleware = [
+            ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
+            ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({ backend, sources: input.resolvedSkills })] : []),
+            ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
+            createSubAgentMiddleware({
+                defaultModel: input.resolvedModel,
+                defaultTools: input.resolvedTools,
+                defaultInterruptOn: input.resolvedInterruptOn,
+                subagents: subagents,
+                generalPurposeAgent: false,
+            }),
+            createSummarizationMiddleware({
+                model: input.resolvedModel,
+                backend,
+            }),
+            createPatchToolCallsMiddleware(),
+            ...(asyncSubagents.length > 0 ? [createAsyncSubAgentMiddleware({ asyncSubAgents: asyncSubagents })] : []),
+            ...input.resolvedMiddleware,
+            ...(getBindingMemorySources(binding).length > 0 ? [createMemoryMiddleware({ backend, sources: getBindingMemorySources(binding) })] : []),
+            ...(input.resolvedInterruptOn ? [humanInTheLoopMiddleware({ interruptOn: input.resolvedInterruptOn })] : []),
+        ];
+        const executionParams = getBindingExecutionParams(binding);
+        const responseFormat = getBindingExecutionKind(binding) === "deepagent"
+            ? (executionParams && "responseFormat" in executionParams ? executionParams.responseFormat : undefined)
+            : undefined;
+        return createAgent({
+            model: input.resolvedModel,
+            systemPrompt: getBindingSystemPrompt(binding),
+            tools: input.resolvedTools,
+            middleware: middleware,
+            name: binding.agent.id,
+            ...(responseFormat !== undefined ? { responseFormat: responseFormat } : {}),
+        });
+    }
     buildRunnableCacheKey(binding, sessionId) {
         const filesystemConfig = getBindingFilesystemConfig(binding);
         const sessionStorage = typeof filesystemConfig?.sessionStorage === "object" && filesystemConfig.sessionStorage
@@ -522,6 +635,12 @@ export class AgentRuntimeAdapter {
             canUseDirectModelStream,
             langChainStreamModel,
             createRunnable: () => this.create(binding, { sessionId }),
+            resolveInvocationConfig: (activeBinding, configOptions) => resolveLangChainInvocationConfig(activeBinding, {
+                sessionId: configOptions.sessionId,
+                requestId: configOptions.requestId,
+                ...(configOptions.context ? { context: configOptions.context } : {}),
+                ...(configOptions.toolRuntimeContext ? { toolRuntimeContext: configOptions.toolRuntimeContext } : {}),
+            }),
             withTimeout: (producer, timeoutMs, operation, stage) => this.withTimeout(producer, timeoutMs, operation, stage),
             iterateWithTimeout: (iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs) => this.iterateWithTimeout(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs),
             invokeTimeoutMs,
@@ -541,4 +660,4 @@ export class AgentRuntimeAdapter {
         });
     }
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, RuntimeOperationTimeoutError, };

package/dist/runtime/agent-runtime-assembly.d.ts

@@ -2,6 +2,7 @@ import type { CompiledAgentBinding, CompiledAsyncSubAgent, RuntimeAdapterOptions
 import type { ExecutableTool } from "./adapter/flow/invoke-runtime.js";
 import type { UpstreamSubagentConfig } from "./adapter/middleware-assembly.js";
 export declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+export declare const DEFAULT_DEEPAGENT_RECURSION_LIMIT = 100;
 export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
     builtinTools: Map<string, ExecutableTool>;
     explicitToolNames?: string[];

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

@@ -4,6 +4,7 @@ import { asStructuredExecutableTool } from "./adapter/tool/resolved-tool.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.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__:";
+export const DEFAULT_DEEPAGENT_RECURSION_LIMIT = 100;
 const BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES = new Set([
     "list_files",
     "search_files",
@@ -88,8 +89,12 @@ export function buildLangChainCreateParams(input) {
     };
 }
 export function resolveLangChainInvocationConfig(binding, options) {
-    const langchainPassthrough = typeof binding.harnessRuntime.langchain?.passthrough === "object" && binding.harnessRuntime.langchain?.passthrough
-        ? binding.harnessRuntime.langchain.passthrough
+    const executionKind = getBindingExecutionKind(binding) ?? binding.agent.executionMode;
+    const runtimePassthrough = executionKind === "deepagent"
+        ? binding.harnessRuntime.deepagent?.passthrough
+        : binding.harnessRuntime.langchain?.passthrough;
+    const langchainPassthrough = typeof runtimePassthrough === "object" && runtimePassthrough
+        ? runtimePassthrough
         : undefined;
     const config = {
         configurable: {
@@ -100,6 +105,9 @@ export function resolveLangChainInvocationConfig(binding, options) {
     if (typeof langchainPassthrough?.recursionLimit === "number") {
         config.recursionLimit = langchainPassthrough.recursionLimit;
     }
+    else if (executionKind === "deepagent") {
+        config.recursionLimit = DEFAULT_DEEPAGENT_RECURSION_LIMIT;
+    }
     if (options.context) {
         config.context = options.context;
     }

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

@@ -1,9 +1,9 @@
 import { readSkillMetadata } from "../../skills/skill-metadata.js";
 import { createUpstreamTimelineReducer } from "../../../projections/upstream-events.js";
 import { formatAgentName } from "../../../utils/agent-display.js";
-import { getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, isDeepAgentBinding, } from "../../support/compiled-binding.js";
+import { getBindingBuiltinToolsConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, isDeepAgentBinding, } from "../../support/compiled-binding.js";
 import { buildRuntimeGovernanceBundles } from "./governance.js";
-import { BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS } from "../../adapter/tool/builtin-middleware-tools.js";
+import { filterBuiltinMiddlewareToolDescriptors } from "../../adapter/tool/builtin-middleware-tools.js";
 import { buildSurfaceId, resolveSurfaceAction, resolveSurfaceDisplayName, } from "./surface-semantics.js";
 function asObject(value) {
     return typeof value === "object" && value !== null ? value : null;
@@ -109,9 +109,8 @@ export function buildRequestRuntimeSnapshot(binding, options) {
     const tools = isDeepAgentBinding(binding)
         ? [
             ...declaredTools,
-            ...BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS
-                .filter((descriptor) => !declaredTools.some((tool) => tool.name === descriptor.name))
-                .map((descriptor) => ({ ...descriptor })),
+            ...filterBuiltinMiddlewareToolDescriptors(getBindingBuiltinToolsConfig(binding))
+                .filter((descriptor) => !declaredTools.some((tool) => tool.name === descriptor.name)),
         ]
         : declaredTools;
     return {

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

@@ -43,7 +43,7 @@ function readTerminalStructuredStatus(value) {
             return readTerminalStructuredStatus(JSON.parse(value));
         }
         catch {
-            return null;
+            return /^\s*Status:\s*completed\b/im.test(value) ? "completed" : null;
         }
     }
     if (typeof value !== "object" || value === null) {
@@ -54,9 +54,20 @@ function readTerminalStructuredStatus(value) {
         return typed.status;
     }
     return (readTerminalStructuredStatus(typed.structuredResponse)
+        ?? readTerminalStructuredStatus(typed.content)
         ?? readTerminalStructuredStatus(typed.output)
         ?? readTerminalStructuredStatus(typed.data));
 }
+function isSubstantiveTerminalAssistantOutput(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (normalized.length < 80) {
+        return false;
+    }
+    if (/\b(?:delegated|waiting|wait for|initiated)\b/i.test(normalized) && !/\b(?:finding|summary|root cause|evidence|completed|result|issue)\b/i.test(normalized)) {
+        return false;
+    }
+    return true;
+}
 function reconcilePlanStateToTerminalStatus(planState, status, updatedAt) {
     const items = planState.items.map((item) => ({
         ...item,
@@ -134,6 +145,57 @@ function buildPlanStateSignature(planState) {
         summary: planState.summary,
     });
 }
+function recomputePlanSummary(items) {
+    return {
+        total: items.length,
+        pending: items.filter((item) => item.status === "pending").length,
+        inProgress: items.filter((item) => item.status === "in_progress").length,
+        completed: items.filter((item) => item.status === "completed").length,
+        failed: items.filter((item) => item.status === "failed").length,
+        cancelled: items.filter((item) => item.status === "cancelled").length,
+    };
+}
+function normalizePlanItemKey(item) {
+    return typeof item.id === "string" && item.id.trim().length > 0
+        ? `id:${item.id.trim()}`
+        : `content:${item.content.trim().toLowerCase()}`;
+}
+function mergePartialPlanState(currentPlanState, incomingPlanState) {
+    if (!currentPlanState || incomingPlanState.items.length >= currentPlanState.items.length) {
+        return incomingPlanState;
+    }
+    const currentByKey = new Map(currentPlanState.items.map((item, index) => [normalizePlanItemKey(item), { item, index }]));
+    const incomingByKey = new Map();
+    for (const incomingItem of incomingPlanState.items) {
+        const key = normalizePlanItemKey(incomingItem);
+        if (!currentByKey.has(key)) {
+            const currentStructuredIds = countStructuredTodoIds(currentPlanState.items);
+            const incomingStructuredIds = countStructuredTodoIds(incomingPlanState.items);
+            if (currentStructuredIds > 0 && incomingStructuredIds === 0) {
+                return currentPlanState;
+            }
+            const mergedItems = currentPlanState.items.map((item, index) => {
+                const incomingByIndex = incomingPlanState.items[index];
+                return incomingByIndex ? { ...item, status: incomingByIndex.status } : item;
+            });
+            return {
+                ...incomingPlanState,
+                items: mergedItems,
+                summary: recomputePlanSummary(mergedItems),
+            };
+        }
+        incomingByKey.set(key, incomingItem);
+    }
+    const mergedItems = currentPlanState.items.map((item) => {
+        const incomingItem = incomingByKey.get(normalizePlanItemKey(item));
+        return incomingItem ? { ...item, ...incomingItem } : item;
+    });
+    return {
+        ...incomingPlanState,
+        items: mergedItems,
+        summary: recomputePlanSummary(mergedItems),
+    };
+}
 function countStructuredTodoIds(items) {
     return items.filter((item) => typeof item.id === "string" && item.id.length > 0).length;
 }
@@ -283,16 +345,23 @@ function summarizePlanState(planState) {
     if (planState.summary.total <= 0) {
         return null;
     }
-    const counts = [
-        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.failed > 0 ? `${planState.summary.failed} failed` : "",
-    ].filter((value) => value.length > 0);
-    if (counts.length === 0) {
-        counts.push(`${planState.summary.total} total`);
-    }
-    return `Plan updated: ${counts.join(", ")}.`;
+    const statusMarker = (status) => {
+        switch (status) {
+            case "completed":
+                return "[x]";
+            case "in_progress":
+                return "[~]";
+            case "failed":
+                return "[!]";
+            case "cancelled":
+                return "[-]";
+            default:
+                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}`;
 }
 function createSurfaceCommentary(surfaceItem) {
     const name = normalizeCommentaryText(surfaceItem.name);
@@ -446,6 +515,10 @@ export async function* streamHarnessRun(options) {
     let delegationChain = [options.selectedAgentId];
     let upstreamEventOrdinal = 0;
     let syntheticFallback;
+    const toolErrors = [];
+    let sawSuccessfulToolResult = false;
+    let lastToolResultKey = null;
+    const executedToolResults = [];
     const emittedCommentary = new Set();
     const emitCommentary = function* (content) {
         const normalized = normalizeCommentaryText(content);
@@ -467,10 +540,6 @@ export async function* streamHarnessRun(options) {
             options.releaseRequestSlotPromise,
         ]).then(([loadedPriorHistory, resolvedReleaseRunSlot]) => [loadedPriorHistory, resolvedReleaseRunSlot]);
         releaseRunSlot = acquiredReleaseRunSlot;
-        const toolErrors = [];
-        let sawSuccessfulToolResult = false;
-        let lastToolResultKey = null;
-        const executedToolResults = [];
         const recalledMemories = options.invocation.memoryRecall?.items ?? [];
         for (const item of createRuntimeMemoryRecallSteps(options.sessionId, options.requestId, recalledMemories)) {
             yield item;
@@ -502,32 +571,16 @@ export async function* streamHarnessRun(options) {
                     updatedAt: new Date().toISOString(),
                 });
                 if (upstreamPlanState) {
-                    const signature = buildPlanStateSignature(upstreamPlanState);
-                    if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, upstreamPlanState)) {
-                        planStateVersion = upstreamPlanState.version;
-                        lastPlanStateSignature = signature;
-                        currentPlanState = 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;
+                    const mergedPlanState = mergePartialPlanState(currentPlanState, upstreamPlanState);
+                    const signature = buildPlanStateSignature(mergedPlanState);
+                    if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, mergedPlanState)) {
+                        planStateVersion = mergedPlanState.version;
                         lastPlanStateSignature = signature;
-                        currentPlanState = reconciledPlanState;
-                        for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
+                        currentPlanState = mergedPlanState;
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
                             yield item;
                         }
-                        const commentary = summarizePlanState(reconciledPlanState);
+                        const commentary = summarizePlanState(mergedPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
@@ -677,20 +730,23 @@ export async function* streamHarnessRun(options) {
                         updatedAt: new Date().toISOString(),
                     });
                 if (planState) {
-                    const signature = buildPlanStateSignature(planState);
-                    if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, planState)) {
+                    const mergedPlanState = mergePartialPlanState(currentPlanState, planState);
+                    const signature = buildPlanStateSignature(mergedPlanState);
+                    if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, mergedPlanState)) {
                         lastPlanStateSignature = signature;
-                        currentPlanState = planState;
-                        for (const item of await emitPlanStateUpdate(options, currentAgentId, planState)) {
+                        currentPlanState = mergedPlanState;
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
                             yield item;
                         }
-                        const commentary = summarizePlanState(planState);
+                        const commentary = summarizePlanState(mergedPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
                     }
                 }
-                const terminalStructuredStatus = readTerminalStructuredStatus(normalizedChunk.output);
+                const terminalStructuredStatus = normalizedChunk.toolName === "task"
+                    ? readTerminalStructuredStatus(normalizedChunk.output)
+                    : null;
                 if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
                     const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
                     const signature = buildPlanStateSignature(reconciledPlanState);
@@ -757,15 +813,16 @@ export async function* streamHarnessRun(options) {
                 updatedAt: new Date().toISOString(),
             });
             if (finalPlanState) {
-                const signature = buildPlanStateSignature(finalPlanState);
-                if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, finalPlanState)) {
-                    planStateVersion = finalPlanState.version;
+                const mergedPlanState = mergePartialPlanState(currentPlanState, finalPlanState);
+                const signature = buildPlanStateSignature(mergedPlanState);
+                if (signature !== lastPlanStateSignature && shouldEmitPlanState(currentPlanState, mergedPlanState)) {
+                    planStateVersion = mergedPlanState.version;
                     lastPlanStateSignature = signature;
-                    currentPlanState = finalPlanState;
-                    for (const item of await emitPlanStateUpdate(options, currentAgentId, finalPlanState)) {
+                    currentPlanState = mergedPlanState;
+                    for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
                         yield item;
                     }
-                    const commentary = summarizePlanState(finalPlanState);
+                    const commentary = summarizePlanState(mergedPlanState);
                     if (commentary) {
                         yield* emitCommentary(commentary);
                     }
@@ -791,6 +848,22 @@ export async function* streamHarnessRun(options) {
             }
         }
         currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
+        if (isSubstantiveTerminalAssistantOutput(assistantOutput) && planStateHasActiveItems(currentPlanState)) {
+            const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, "completed", 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);
+                }
+            }
+        }
         if (assistantOutputCameFromInvokeFallback
             && nonUpstreamStreamActivityObserved
             && planStateHasActiveItems(currentPlanState)) {
@@ -833,6 +906,63 @@ export async function* streamHarnessRun(options) {
         };
     }
     catch (error) {
+        const deterministicToolEvidenceOutput = resolveDeterministicFinalOutput({
+            visibleOutput: assistantOutput,
+            executedToolResults,
+        });
+        if (!assistantOutput && sawSuccessfulToolResult && deterministicToolEvidenceOutput) {
+            const terminalStructuredStatus = readTerminalStructuredStatus(deterministicToolEvidenceOutput);
+            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);
+                    }
+                }
+            }
+            await options.appendAssistantMessage(options.sessionId, options.requestId, deterministicToolEvidenceOutput);
+            yield {
+                type: "event",
+                event: await options.emit(options.sessionId, options.requestId, 3, "output.delta", { content: deterministicToolEvidenceOutput }),
+            };
+            yield {
+                type: "content",
+                sessionId: options.sessionId,
+                requestId: options.requestId,
+                agentId: currentAgentId,
+                content: deterministicToolEvidenceOutput,
+            };
+            const completedEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "completed", {
+                previousState: "running",
+            });
+            yield {
+                type: "event",
+                event: completedEvent,
+            };
+            yield {
+                type: "result",
+                result: {
+                    sessionId: options.sessionId,
+                    requestId: options.requestId,
+                    agentId: currentAgentId,
+                    state: "completed",
+                    output: deterministicToolEvidenceOutput,
+                    finalMessageText: deterministicToolEvidenceOutput,
+                    metadata: {
+                        executedToolResults,
+                    },
+                },
+            };
+            return;
+        }
         const shouldRetryAfterStreamingCompatibilityError = !assistantOutput &&
             isOpenAICompatibleStreamingCompatibilityError(options.binding, error);
         if ((emitted || streamActivityObserved)

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

@@ -1,4 +1,4 @@
-export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
+export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
 export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 export { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, readTextContent, sanitizeVisibleText, } from "./output-content.js";
 export { isLikelyToolArgsObject, salvageToolArgs, tryParseJson, } from "./output-tool-args.js";

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

@@ -1,4 +1,4 @@
-export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
+export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
 export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 export { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, readTextContent, sanitizeVisibleText, } from "./output-content.js";
 export { isLikelyToolArgsObject, salvageToolArgs, tryParseJson, } from "./output-tool-args.js";