@botbotgo/agent-harness 0.0.463 → 0.0.465

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -86,6 +86,19 @@ function readSchemaDescription(schemaPart) {
     }
     return readSchemaDescription(def?.innerType);
 }
+function schemaPartExpectsString(schemaPart) {
+    if (!isObject(schemaPart)) {
+        return false;
+    }
+    if (schemaPart.type === "string") {
+        return true;
+    }
+    const def = schemaPart._def ?? schemaPart.def;
+    if (def?.typeName === "ZodString" || def?.type === "string") {
+        return true;
+    }
+    return schemaPartExpectsString(def?.innerType);
+}
 function fillLatestUserInputForQueryLikeFields(args, shape, latestUserInput) {
     const userInput = typeof latestUserInput === "string" ? latestUserInput.trim() : "";
     if (!userInput) {
@@ -100,7 +113,7 @@ function fillLatestUserInputForQueryLikeFields(args, shape, latestUserInput) {
         const description = readSchemaDescription(schemaPart);
         const keyIsQueryLike = ["query", "question", "prompt", "input", "text"].includes(normalizedKey);
         const descriptionIsQueryLike = /\b(?:query|question|prompt|input|text)\b/iu.test(description);
-        if (!keyIsQueryLike && !descriptionIsQueryLike) {
+        if ((!keyIsQueryLike && !descriptionIsQueryLike) || !schemaPartExpectsString(schemaPart)) {
             continue;
         }
         next = {
@@ -110,6 +123,27 @@ function fillLatestUserInputForQueryLikeFields(args, shape, latestUserInput) {
     }
     return next;
 }
+function fillLatestUserInputForResourceArrayFields(args, shape, latestUserInput) {
+    const userInput = typeof latestUserInput === "string" ? latestUserInput.trim() : "";
+    if (!userInput || !hasExplicitResourceReference(userInput)) {
+        return args;
+    }
+    const resourceRefs = extractExplicitResourceReferences(userInput);
+    if (resourceRefs.length === 0) {
+        return args;
+    }
+    let next = args;
+    for (const [key, schemaPart] of Object.entries(shape)) {
+        if (key in next || !schemaPartExpectsArray(schemaPart)) {
+            continue;
+        }
+        const mapped = resourceRefs.map((ref) => inferDiscriminatedArrayObjectFromString(schemaPart, ref));
+        if (mapped.length > 0 && mapped.every((item) => item !== null)) {
+            next = { ...next, [key]: mapped };
+        }
+    }
+    return next;
+}
 function mapCommonArgumentAliases(args, shape) {
     let next = args;
     if ("args" in shape && !("args" in next) && Array.isArray(next.argv)) {
@@ -133,10 +167,96 @@ function schemaPartExpectsArray(schemaPart) {
     }
     return schemaPartExpectsArray(def?.innerType);
 }
+function readObjectShape(schemaPart) {
+    if (!isObject(schemaPart)) {
+        return undefined;
+    }
+    const def = schemaPart._def ?? schemaPart.def;
+    if (!def) {
+        return undefined;
+    }
+    const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+    return isRecord(shape) ? shape : readObjectShape(def.innerType);
+}
+function readLiteralValue(schemaPart) {
+    if (!isObject(schemaPart)) {
+        return undefined;
+    }
+    const def = schemaPart._def ?? schemaPart.def;
+    if ((def?.typeName === "ZodLiteral" || def?.type === "literal") && typeof def.value === "string") {
+        return def.value;
+    }
+    if ((def?.typeName === "ZodLiteral" || def?.type === "literal") && Array.isArray(def.values) && typeof def.values[0] === "string") {
+        return def.values[0];
+    }
+    return readLiteralValue(def?.innerType);
+}
+function readArrayElementSchema(schemaPart) {
+    if (!isObject(schemaPart)) {
+        return undefined;
+    }
+    const def = schemaPart._def ?? schemaPart.def;
+    if (def?.typeName === "ZodArray" || def?.type === "array") {
+        return def.element ?? def.type;
+    }
+    return readArrayElementSchema(def?.innerType);
+}
+function inferDiscriminatedArrayObjectFromString(schemaPart, value) {
+    const raw = value.trim();
+    if (!raw) {
+        return null;
+    }
+    const elementSchema = readArrayElementSchema(schemaPart);
+    if (!isObject(elementSchema)) {
+        return null;
+    }
+    const def = elementSchema._def ?? elementSchema.def;
+    const options = Array.isArray(def?.options)
+        ? def.options
+        : Array.isArray(elementSchema.options)
+            ? elementSchema.options
+            : undefined;
+    if (def?.typeName !== "ZodDiscriminatedUnion"
+        && !(def?.type === "union" && typeof def.discriminator === "string")) {
+        return null;
+    }
+    if (typeof def.discriminator !== "string" || !options) {
+        return null;
+    }
+    const looksLikeUrl = /^https?:\/\/\S+$/iu.test(raw);
+    for (const option of options) {
+        const optionShape = readObjectShape(option);
+        if (!optionShape) {
+            continue;
+        }
+        const discriminatorValue = readLiteralValue(optionShape[def.discriminator]);
+        if (!discriminatorValue) {
+            continue;
+        }
+        if (looksLikeUrl && "url" in optionShape) {
+            return { [def.discriminator]: discriminatorValue, url: raw };
+        }
+        const looksLikePath = /^(?:\.{1,2}\/|\/|~\/|[A-Za-z]:[\\/])|\\|\.[A-Za-z0-9]{1,12}$/u.test(raw);
+        if (!looksLikeUrl && looksLikePath && "path" in optionShape && !raw.includes("\n")) {
+            return { [def.discriminator]: discriminatorValue, path: raw };
+        }
+        if ("text" in optionShape) {
+            return { [def.discriminator]: discriminatorValue, text: raw };
+        }
+    }
+    return null;
+}
 function mapStringArrayFields(args, shape) {
     let next = args;
     for (const [key, schemaPart] of Object.entries(shape)) {
         const value = next[key];
+        if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+            const mapped = value.map((item) => inferDiscriminatedArrayObjectFromString(schemaPart, item));
+            if (mapped.length > 0 && mapped.every((item) => item !== null)) {
+                next = { ...next, [key]: mapped };
+            }
+            continue;
+        }
         if (typeof value !== "string") {
             continue;
         }
@@ -175,6 +295,9 @@ function mapDelimitedListLikeArgs(args) {
     }
     return next;
 }
+function stripArgsToShape(args, shape) {
+    return Object.fromEntries(Object.entries(args).filter(([key]) => key in shape));
+}
 function dropDelimitedScalarPathArgs(args, shape) {
     let next = args;
     for (const [key, schemaPart] of Object.entries(shape)) {
@@ -199,7 +322,10 @@ function dropDelimitedScalarPathArgs(args, shape) {
     return next;
 }
 export function normalizeToolArgsForSchema(args, schema, rawArgsInput, options = {}) {
-    const schemaDef = isObject(schema) ? schema._def : undefined;
+    const schemaDef = isObject(schema)
+        ? (schema._def
+            ?? schema.def)
+        : undefined;
     const zodShape = schemaDef
         ? isRecord(schemaDef.shape)
             ? schemaDef.shape
@@ -210,38 +336,47 @@ export function normalizeToolArgsForSchema(args, schema, rawArgsInput, options =
     const jsonShape = isObject(schema) && isRecord(schema.properties)
         ? (schema.properties ?? undefined)
         : undefined;
-    const shape = zodShape && isRecord(zodShape) ? zodShape : jsonShape;
+    const plainShape = isObject(schema)
+        && !("_def" in schema)
+        && !("properties" in schema)
+        && Object.values(schema).every((value) => isObject(value))
+        ? schema
+        : undefined;
+    const shape = zodShape && isRecord(zodShape) ? zodShape : jsonShape ?? plainShape;
     if (!shape || !isRecord(shape)) {
         return mapDelimitedListLikeArgs(args);
     }
-    const aliasMappedArgs = dropDelimitedScalarPathArgs(mapStringArrayFields(mapCommonArgumentAliases(args, shape), shape), shape);
+    const stripUnknownArgs = plainShape !== undefined && !zodShape && !jsonShape;
+    const aliasMappedArgs = dropDelimitedScalarPathArgs(fillLatestUserInputForResourceArrayFields(mapStringArrayFields(mapCommonArgumentAliases(args, shape), shape), shape, options.latestUserInput), shape);
     const keys = Object.keys(shape);
     if (keys.length !== 1) {
-        return fillLatestUserInputForQueryLikeFields(aliasMappedArgs, shape, options.latestUserInput);
+        const filled = fillLatestUserInputForQueryLikeFields(aliasMappedArgs, shape, options.latestUserInput);
+        return stripUnknownArgs ? stripArgsToShape(filled, shape) : filled;
     }
     const [expectedKey] = keys;
     if (expectedKey in aliasMappedArgs) {
-        return aliasMappedArgs;
+        return stripUnknownArgs ? stripArgsToShape(aliasMappedArgs, shape) : aliasMappedArgs;
     }
     const scalarMappedArgs = mapSingleFieldScalarArg(aliasMappedArgs, expectedKey, rawArgsInput);
     if (expectedKey in scalarMappedArgs) {
-        return scalarMappedArgs;
+        return stripUnknownArgs ? stripArgsToShape(scalarMappedArgs, shape) : scalarMappedArgs;
     }
     if (Object.keys(scalarMappedArgs).length === 0 && typeof options.latestUserInput === "string") {
         const userInput = options.latestUserInput.trim();
         const resourceRefs = extractExplicitResourceReferences(userInput);
         if (resourceRefs.length === 1 && hasExplicitResourceReference(userInput)) {
-            return {
+            const filled = {
                 ...scalarMappedArgs,
                 [expectedKey]: resourceRefs[0],
             };
+            return stripUnknownArgs ? stripArgsToShape(filled, shape) : filled;
         }
     }
     const genericScalarMappedArgs = mapSingleRemainingScalarArg(scalarMappedArgs, expectedKey);
     if (expectedKey in genericScalarMappedArgs) {
-        return genericScalarMappedArgs;
+        return stripUnknownArgs ? stripArgsToShape(genericScalarMappedArgs, shape) : genericScalarMappedArgs;
     }
-    return genericScalarMappedArgs;
+    return stripUnknownArgs ? stripArgsToShape(genericScalarMappedArgs, shape) : genericScalarMappedArgs;
 }
 export function extractToolCallsFromResult(result) {
     const capturedToolCalls = readCapturedPromptedJsonToolCalls(result);

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

@@ -62,6 +62,11 @@ export declare class AgentRuntimeAdapter {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
+        externalPlanEvidenceTools?: Array<{
+            name: string;
+            args?: Record<string, unknown>;
+            id?: string;
+        }>;
     }): Promise<RequestResult>;
     private tryDelegateWithCompactRouter;
     private buildCompactDelegationReport;
@@ -75,6 +80,13 @@ export declare class AgentRuntimeAdapter {
         memoryContext?: string;
         profiling?: boolean;
         toolRuntimeContext?: Record<string, unknown>;
+        suppressInitialRequiredPlanInstruction?: boolean;
+        externalPlanEvidence?: boolean;
+        externalPlanEvidenceTools?: Array<{
+            name: string;
+            args?: Record<string, unknown>;
+            id?: string;
+        }>;
     }): AsyncGenerator<RuntimeStreamChunk | string>;
 }
 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

@@ -8,7 +8,9 @@ import { extractMessageText } from "../utils/message-content.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildDeepAgentSystemPromptWithCapabilityCatalog, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
 import { resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
+import { PROMPTED_JSON_TOOL_POLICY_KEY } from "./adapter/model/prompted-json-tool-policy.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
+import { extractExplicitResourceReferences } from "./harness/system/runtime-memory-policy.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { resolveDeterministicFinalOutput } from "./adapter/invocation-result.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";
@@ -243,6 +245,9 @@ function isDelegationOnlyDeepAgentBinding(binding) {
         && getBindingSkills(binding).length === 0;
 }
 function hasDelegatedPlanEvidence(result) {
+    if (result?.metadata?.externalPlanEvidence === true) {
+        return true;
+    }
     const toolResults = result?.metadata?.executedToolResults;
     return Array.isArray(toolResults)
         && toolResults.some((item) => isPlanToolName(item.toolName));
@@ -264,14 +269,62 @@ function hasIncompleteDelegatedTodos(value) {
         || hasIncompleteDelegatedTodos(record.stateSnapshot)
         || hasIncompleteDelegatedTodos(record.metadata);
 }
+function hasFailedDelegatedTodos(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => hasFailedDelegatedTodos(item));
+    }
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const record = value;
+    const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
+    if (status === "failed") {
+        return true;
+    }
+    return hasFailedDelegatedTodos(record.todos)
+        || hasFailedDelegatedTodos(record.update)
+        || hasFailedDelegatedTodos(record.stateSnapshot)
+        || hasFailedDelegatedTodos(record.metadata);
+}
 function hasIncompleteDelegatedPlanState(result) {
     const toolResults = result?.metadata?.executedToolResults;
     return Array.isArray(toolResults)
         && toolResults.some((item) => isPlanToolName(item.toolName) && hasIncompleteDelegatedTodos(item.output));
 }
+function hasFailedDelegatedPlanState(result) {
+    const toolResults = result?.metadata?.executedToolResults;
+    return Array.isArray(toolResults)
+        && toolResults.some((item) => isPlanToolName(item.toolName) && hasFailedDelegatedTodos(item.output));
+}
+function hasDelegatedNonPlanToolEvidence(result) {
+    const toolResults = result?.metadata?.executedToolResults;
+    return Array.isArray(toolResults)
+        && toolResults.some((item) => typeof item.toolName === "string" && !isPlanToolName(item.toolName) && item.isError !== true);
+}
+function hasNonPlanToolEvidenceItems(items) {
+    return items.some((item) => typeof item.toolName === "string" && !isPlanToolName(item.toolName) && item.isError !== true);
+}
+function buildDelegatedExternalPlanEvidenceSummary(items) {
+    const evidence = items
+        .filter((item) => typeof item.toolName === "string" && !isPlanToolName(item.toolName) && item.isError !== true)
+        .map((item) => {
+        const output = typeof item.output === "string" ? item.output : JSON.stringify(item.output ?? "");
+        return `## ${String(item.toolName)}\n${output}`;
+    });
+    return [
+        "Status: completed",
+        "Summary:",
+        "- Completed delegated recovery after collecting non-planning tool evidence.",
+        "",
+        "Evidence:",
+        evidence.length > 0 ? evidence.join("\n\n") : "(no non-planning tool evidence captured)",
+    ].join("\n");
+}
 function needsDelegatedPlanRecovery(binding, result) {
     return binding?.harnessRuntime.executionContract?.requiresPlan === true
-        && (!hasDelegatedPlanEvidence(result) || hasIncompleteDelegatedPlanState(result));
+        && (!hasDelegatedPlanEvidence(result)
+            || hasIncompleteDelegatedPlanState(result)
+            || (hasFailedDelegatedPlanState(result) && !hasDelegatedNonPlanToolEvidence(result)));
 }
 function readUpstreamToolEvidence(event) {
     if (typeof event !== "object" || event === null) {
@@ -334,11 +387,87 @@ const DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION = [
     "Then continue the task to completion, update TODO statuses after evidence steps, and close every TODO as completed or failed before the final answer.",
 ].join("\n");
 const DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION = [
-    "The delegated task still has no visible TODO planning evidence.",
-    "Use the actual write_todos tool interface now. Do not print JSON, markdown, or a tool-call transcript as text.",
-    "The next runtime event must be the write_todos tool call result, not an assistant message describing the call.",
-    "After write_todos succeeds, continue the delegated task and close every TODO as completed or failed.",
+    "The delegated task has already attempted TODO planning but still has no successful non-planning tool evidence.",
+    "Do not call write_todos or read_todos next.",
+    "The next runtime event must be one available non-planning evidence tool call.",
+    "After that tool returns, update or close the TODO board and provide the final answer required by the agent response format.",
 ].join("\n");
+function buildDelegatedPlanEvidenceRecoveryOptions(binding, baseOptions, requestText = "") {
+    const nonPlanningTools = binding
+        ? getBindingPrimaryTools(binding).filter((tool) => !isPlanToolName(tool.name))
+        : [];
+    const explicitlyRequestedTools = resolveExplicitlyRequestedToolNames(requestText, nonPlanningTools.map((tool) => tool.name));
+    const externalPlanEvidenceTools = explicitlyRequestedTools.length === 1
+        ? [{
+                name: explicitlyRequestedTools[0],
+                args: buildExternalPlanEvidenceArgs(nonPlanningTools.find((tool) => tool.name === explicitlyRequestedTools[0]), requestText),
+                id: "delegated-plan-evidence-tool-1",
+            }]
+        : nonPlanningTools.length === 1
+            ? [{
+                    name: nonPlanningTools[0].name,
+                    args: buildExternalPlanEvidenceArgs(nonPlanningTools[0], requestText),
+                    id: "delegated-plan-evidence-tool-1",
+                }]
+            : nonPlanningTools.length > 1
+                ? [{
+                        name: nonPlanningTools[0].name,
+                        args: buildExternalPlanEvidenceArgs(nonPlanningTools[0], requestText),
+                        id: "delegated-plan-evidence-tool-1",
+                    }]
+                : undefined;
+    return {
+        ...baseOptions,
+        suppressInitialRequiredPlanInstruction: true,
+        externalPlanEvidence: true,
+        ...(externalPlanEvidenceTools ? { externalPlanEvidenceTools } : {}),
+        state: {
+            ...(typeof baseOptions.state === "object" && baseOptions.state !== null ? baseOptions.state : {}),
+            [PROMPTED_JSON_TOOL_POLICY_KEY]: "nonPlanningEvidence",
+        },
+    };
+}
+function buildExternalPlanEvidenceArgs(tool, requestText) {
+    const properties = tool?.modelSchema && typeof tool.modelSchema === "object"
+        && tool.modelSchema !== null
+        && typeof tool.modelSchema.properties === "object"
+        && tool.modelSchema.properties !== null
+        ? tool.modelSchema.properties
+        : {};
+    const refs = extractExplicitResourceReferences(requestText);
+    const args = {};
+    const firstUrl = refs.find((ref) => /^https?:\/\//iu.test(ref));
+    if ("url" in properties && firstUrl) {
+        args.url = firstUrl;
+    }
+    if ("sources" in properties && refs.length > 0) {
+        args.sources = refs.map((ref) => /^https?:\/\//iu.test(ref)
+            ? { type: "url", url: ref }
+            : { type: "text", text: ref });
+    }
+    if ("question" in properties) {
+        args.question = requestText;
+    }
+    else if ("query" in properties) {
+        args.query = requestText;
+    }
+    return args;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function resolveExplicitlyRequestedToolNames(text, availableToolNames) {
+    if (!text.trim() || availableToolNames.length === 0) {
+        return [];
+    }
+    return availableToolNames.filter((toolName) => {
+        const trimmed = toolName.trim();
+        if (!trimmed) {
+            return false;
+        }
+        return new RegExp(`(^|[^A-Za-z0-9_])${escapeRegExp(trimmed)}([^A-Za-z0-9_]|$)`, "u").test(text);
+    });
+}
 function looksLikeRawCommandTranscript(value) {
     const normalized = value.trim();
     return /^(?:stdout|stderr)\s*:/iu.test(normalized)
@@ -505,18 +634,21 @@ export class AgentRuntimeAdapter {
         if (!this.options.functionToolContextResolver) {
             return undefined;
         }
+        const publicRequestId = typeof options.requestId === "string" && options.requestId.includes(":")
+            ? options.requestId.split(":")[0]
+            : options.requestId;
         const backend = this.resolveBuiltinMiddlewareBackend(binding, options);
         return {
             ...this.options.functionToolContextResolver({
                 binding,
                 sessionId: options.sessionId,
-                requestId: options.requestId,
+                requestId: publicRequestId,
             }),
             backend,
             invocation: {
                 ...(options.context ? { context: options.context } : {}),
                 ...(options.sessionId ? { sessionId: options.sessionId } : {}),
-                ...(options.requestId ? { requestId: options.requestId } : {}),
+                ...(publicRequestId ? { requestId: publicRequestId } : {}),
             },
         };
     }
@@ -1195,13 +1327,25 @@ export class AgentRuntimeAdapter {
         if (!selectedBinding) {
             return null;
         }
-        const runDelegatedRequest = (text, requestSuffix = "", delegatedOptions = {}) => this.invoke(selectedBinding, text, sessionId, `${requestId}:${subagentType}${requestSuffix}`, undefined, [], {
-            context: options.context,
-            state: options.state,
-            files: options.files,
-            memoryContext: options.memoryContext,
-            ...delegatedOptions,
-        });
+        const runDelegatedRequest = async (text, requestSuffix = "", delegatedOptions = {}) => {
+            const result = await this.invoke(selectedBinding, text, sessionId, `${requestId}:${subagentType}${requestSuffix}`, undefined, [], {
+                context: options.context,
+                state: options.state,
+                files: options.files,
+                memoryContext: options.memoryContext,
+                ...delegatedOptions,
+            });
+            if (delegatedOptions.externalPlanEvidence === true) {
+                return {
+                    ...result,
+                    metadata: {
+                        ...(result.metadata ?? {}),
+                        externalPlanEvidence: true,
+                    },
+                };
+            }
+            return result;
+        };
         let delegatedResult;
         try {
             delegatedResult = await runDelegatedRequest(requestText);
@@ -1261,6 +1405,25 @@ export class AgentRuntimeAdapter {
                 };
             }
         }
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
+            const previousDelegatedResult = delegatedResult;
+            try {
+                delegatedResult = mergeDelegatedResultToolEvidence(await runDelegatedRequest([requestText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry", buildDelegatedPlanEvidenceRecoveryOptions(selectedBinding, options, requestText)), previousDelegatedResult);
+            }
+            catch (error) {
+                const output = error instanceof Error ? error.message : String(error);
+                return {
+                    toolOutput: output,
+                    delegatedSubagentType: subagentType,
+                    delegatedResult: {
+                        ...delegatedResult,
+                        state: "failed",
+                        output,
+                        finalMessageText: output,
+                    },
+                };
+            }
+        }
         if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
             return {
@@ -1318,9 +1481,10 @@ export class AgentRuntimeAdapter {
         const state = compactDelegation.delegatedResult?.state === "failed" ? "failed" : "completed";
         const uniqueToolNames = [...new Set(delegatedToolNames)];
         const toolEvidence = uniqueToolNames.length > 0 ? uniqueToolNames.join(", ") : "none";
+        const hasPlanEvidence = hasDelegatedPlanEvidence(compactDelegation.delegatedResult);
         const fallbackTodoTrace = [
             `1) TODO observed: delegated to ${delegatedSubagentType}.`,
-            uniqueToolNames.some((toolName) => isPlanToolName(toolName))
+            hasPlanEvidence
                 ? `2) ${delegatedSubagentType}: TODO evidence observed; delegated specialist invoked write_todos.`
                 : `2) ${delegatedSubagentType}: TODO evidence missing; delegated specialist did not expose write_todos in returned metadata.`,
             state === "failed"
@@ -1563,7 +1727,7 @@ export class AgentRuntimeAdapter {
                 content: `Planned delegation tree: ${executableDelegations.map((item) => item.subagentType).join(" -> ")}.`,
                 agentId: binding.agent.id,
             };
-            const runPlannedDelegation = async function* (subagentType, text, requestIdSuffix = "") {
+            const runPlannedDelegation = async function* (subagentType, text, requestIdSuffix = "", delegatedOptions = {}) {
                 const selectedBinding = this.options.bindingResolver?.(subagentType);
                 if (!selectedBinding) {
                     const output = `Configured subagent '${subagentType}' could not be resolved.`;
@@ -1582,11 +1746,14 @@ export class AgentRuntimeAdapter {
                 try {
                     for await (const chunk of this.stream(selectedBinding, text, sessionId, [], {
                         context: options.context,
-                        state: options.state,
+                        state: delegatedOptions.state ?? options.state,
                         files: options.files,
                         requestId: `${requestId}:${subagentType}${requestIdSuffix}`,
                         memoryContext: options.memoryContext,
                         profiling: options.profiling,
+                        suppressInitialRequiredPlanInstruction: delegatedOptions.suppressInitialRequiredPlanInstruction,
+                        externalPlanEvidence: delegatedOptions.externalPlanEvidence,
+                        externalPlanEvidenceTools: delegatedOptions.externalPlanEvidenceTools,
                     })) {
                         if (typeof chunk === "string") {
                             output += chunk;
@@ -1621,17 +1788,26 @@ export class AgentRuntimeAdapter {
                         state: "failed",
                         output,
                         finalMessageText: output,
-                        metadata: { executedToolResults },
+                        metadata: {
+                            executedToolResults,
+                            ...(delegatedOptions.externalPlanEvidence === true ? { externalPlanEvidence: true } : {}),
+                        },
                     };
                 }
+                const finalOutput = delegatedOptions.externalPlanEvidence === true && hasNonPlanToolEvidenceItems(executedToolResults)
+                    ? buildDelegatedExternalPlanEvidenceSummary(executedToolResults)
+                    : sanitizeVisibleText(output);
                 return {
                     sessionId,
                     requestId: `${requestId}:${subagentType}${requestIdSuffix}`,
                     agentId: selectedBinding.agent.id,
                     state: "completed",
-                    output: sanitizeVisibleText(output),
-                    finalMessageText: sanitizeVisibleText(output),
-                    metadata: { executedToolResults },
+                    output: finalOutput,
+                    finalMessageText: finalOutput,
+                    metadata: {
+                        executedToolResults,
+                        ...(delegatedOptions.externalPlanEvidence === true ? { externalPlanEvidence: true } : {}),
+                    },
                 };
             }.bind(this);
             for (const [index, planned] of executableDelegations.entries()) {
@@ -1658,7 +1834,7 @@ export class AgentRuntimeAdapter {
                 }
                 if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
                     const previousDelegatedResult = delegatedResult;
-                    delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry"), previousDelegatedResult);
+                    delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry", buildDelegatedPlanEvidenceRecoveryOptions(selectedBinding, options, delegatedText)), previousDelegatedResult);
                 }
                 if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
                     const output = buildDelegatedPlanEvidenceBlocker(selectedBinding?.agent.id ?? planned.subagentType);
@@ -1789,17 +1965,20 @@ export class AgentRuntimeAdapter {
             agentId: selectedBinding.agent.id,
         };
         const childRequestId = `${requestId}:${subagentType}`;
-        const runDelegatedStreamAttempt = async function* (text, requestIdSuffix = "") {
+        const runDelegatedStreamAttempt = async function* (text, requestIdSuffix = "", delegatedOptions = {}) {
             const executedToolResults = [];
             let output = "";
             try {
                 for await (const chunk of this.stream(selectedBinding, text, sessionId, [], {
                     context: options.context,
-                    state: options.state,
+                    state: delegatedOptions.state ?? options.state,
                     files: options.files,
                     requestId: `${childRequestId}${requestIdSuffix}`,
                     memoryContext: options.memoryContext,
                     profiling: options.profiling,
+                    suppressInitialRequiredPlanInstruction: delegatedOptions.suppressInitialRequiredPlanInstruction,
+                    externalPlanEvidence: delegatedOptions.externalPlanEvidence,
+                    externalPlanEvidenceTools: delegatedOptions.externalPlanEvidenceTools,
                 })) {
                     if (typeof chunk === "string") {
                         output += chunk;
@@ -1834,17 +2013,26 @@ export class AgentRuntimeAdapter {
                     state: "failed",
                     output,
                     finalMessageText: output,
-                    metadata: { executedToolResults },
+                    metadata: {
+                        executedToolResults,
+                        ...(delegatedOptions.externalPlanEvidence === true ? { externalPlanEvidence: true } : {}),
+                    },
                 };
             }
+            const finalOutput = delegatedOptions.externalPlanEvidence === true && hasNonPlanToolEvidenceItems(executedToolResults)
+                ? buildDelegatedExternalPlanEvidenceSummary(executedToolResults)
+                : sanitizeVisibleText(output);
             return {
                 sessionId,
                 requestId: `${childRequestId}${requestIdSuffix}`,
                 agentId: selectedBinding.agent.id,
                 state: "completed",
-                output: sanitizeVisibleText(output),
-                finalMessageText: sanitizeVisibleText(output),
-                metadata: { executedToolResults },
+                output: finalOutput,
+                finalMessageText: finalOutput,
+                metadata: {
+                    executedToolResults,
+                    ...(delegatedOptions.externalPlanEvidence === true ? { externalPlanEvidence: true } : {}),
+                },
             };
         }.bind(this);
         const delegatedText = buildDelegatedOwnedTaskInstruction({
@@ -1859,7 +2047,7 @@ export class AgentRuntimeAdapter {
         }
         if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
-            delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry"), previousDelegatedResult);
+            delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry", buildDelegatedPlanEvidenceRecoveryOptions(selectedBinding, options, delegatedText)), previousDelegatedResult);
         }
         if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);

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

@@ -59,7 +59,8 @@ export function isToolCallValidationFailure(error) {
     if (/Invalid input:\s*expected .* received undefined/i.test(message) && /"path"\s*:\s*\[/.test(message)) {
         return true;
     }
-    return /Received tool input did not match expected schema/i.test(message) && /(?:→\s*at|at)\s+[\w[\].]+/i.test(message);
+    return /Received tool input did not match expected schema/i.test(message)
+        && (/(?:→\s*at|at)\s+[\w[\].]+/i.test(message) || /\bDetails:/i.test(message));
 }
 function collectErrorMessages(error) {
     if (!error)