@botbotgo/agent-harness 0.0.357 → 0.0.361

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.357";
+export declare const AGENT_HARNESS_VERSION = "0.0.361";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-25";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.357";
+export const AGENT_HARNESS_VERSION = "0.0.361";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-25";

package/dist/runtime/adapter/compat/deepagent-compat.js

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { existsSync } from "node:fs";
 export function relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) {
     if (!workspaceRoot || !skillPaths) {
         return skillPaths;
@@ -26,17 +25,5 @@ export function resolveDeepAgentSkillSourcePaths(options) {
     return relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
 }
 export function resolveDeepAgentSkillSourceRootPaths(options) {
-    const { workspaceRoot, skillPaths } = options;
-    if (!skillPaths) {
-        return skillPaths;
-    }
-    const sourceRoots = Array.from(new Set(skillPaths.map((skillPath) => {
-        const absolutePath = path.isAbsolute(skillPath) || !workspaceRoot
-            ? skillPath
-            : path.resolve(workspaceRoot, skillPath);
-        return existsSync(path.join(absolutePath, "SKILL.md"))
-            ? path.dirname(absolutePath)
-            : absolutePath;
-    })));
-    return relativizeDeepAgentSkillSourcePaths(workspaceRoot, sourceRoots) ?? sourceRoots;
+    return resolveDeepAgentSkillSourcePaths(options);
 }

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

@@ -7,7 +7,7 @@ import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../ups
 import { appendToolRecoveryInstruction, extractVisibleOutput, tryParseJson } from "../../parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
 import { isEmptyFinalAiMessageError } from "../resilience.js";
-import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION } from "../../prompts/runtime-prompts.js";
+import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
 function readBindingExecutionParams(binding) {
     const params = binding.execution?.params ?? binding.deepAgentParams ?? binding.langchainAgentParams;
     return {
@@ -37,6 +37,9 @@ function isDelegationOnlyBinding(binding) {
 function hasTaskDelegationEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.toolName === "task");
 }
+function hasPlanToolEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.toolName === "write_todos" || item.toolName === "read_todos");
+}
 function hasIncompleteTodos(value) {
     if (!Array.isArray(value)) {
         return false;
@@ -73,6 +76,17 @@ function hasNativeTaskDelegationIntent(value) {
     }
     return hasNativeTaskDelegationIntent(typed.tool_calls) || hasNativeTaskDelegationIntent(typed.messages);
 }
+function looksLikeCapabilityRefusalWithoutEvidence(value) {
+    const text = extractVisibleOutput(value).trim();
+    if (!text) {
+        return false;
+    }
+    const refusalSignal = /(?:cannot|can't|unable to|do not have|don't have|not support|does not support|missing capabilities|tool limitation|skill limitation|capability limitation|out of scope|无法|不能|不支持|缺少能力|能力不足|超出范围)/iu.test(text);
+    if (!refusalSignal) {
+        return false;
+    }
+    return /(?:tool|tools|skill|skills|capabilit|scope|工具|技能|能力|范围)/iu.test(text);
+}
 function readStructuredToolCall(value) {
     const salvaged = salvageJsonToolCalls(value)[0];
     if (salvaged) {
@@ -314,6 +328,19 @@ export async function executeRequestInvocation(options) {
     if (!result) {
         throw new Error("Agent invocation returned no result");
     }
+    if (options.resumePayload === undefined
+        && options.binding.harnessRuntime.executionContract?.requiresPlan === true
+        && !hasPlanToolEvidence(executedToolResults)) {
+        const messages = Array.isArray(result.messages)
+            ? result.messages
+            : undefined;
+        const recoveryBase = messages ? { messages } : request;
+        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION);
+        const recoveredInvocation = await invokeOnce(recoveredRequest);
+        localOrUpstreamInvocation = recoveredInvocation;
+        result = recoveredInvocation.result;
+        executedToolResults.splice(0, executedToolResults.length, ...recoveredInvocation.executedToolResults);
+    }
     if (options.resumePayload === undefined
         && options.binding.harnessRuntime.executionContract?.requiresPlan === true
         && hasIncompleteUpstreamPlan(result)
@@ -328,6 +355,20 @@ export async function executeRequestInvocation(options) {
         result = recoveredInvocation.result;
         executedToolResults.splice(0, executedToolResults.length, ...recoveredInvocation.executedToolResults);
     }
+    if (options.resumePayload === undefined
+        && primaryTools.length > 0
+        && executedToolResults.length === 0
+        && looksLikeCapabilityRefusalWithoutEvidence(result)) {
+        const messages = Array.isArray(result.messages)
+            ? result.messages
+            : undefined;
+        const recoveryBase = messages ? { messages } : request;
+        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION);
+        const recoveredInvocation = await invokeOnce(recoveredRequest);
+        localOrUpstreamInvocation = recoveredInvocation;
+        result = recoveredInvocation.result;
+        executedToolResults.splice(0, executedToolResults.length, ...recoveredInvocation.executedToolResults);
+    }
     try {
         return finalizeRequestResult({
             bindingAgentId: options.binding.agent.id,

package/dist/runtime/adapter/invocation-result.js

@@ -36,6 +36,17 @@ function hasIncompleteStateSnapshotPlan(stateSnapshot) {
         return status === "pending" || status === "in_progress";
     });
 }
+function hasStateSnapshotPlan(stateSnapshot) {
+    return typeof stateSnapshot === "object"
+        && stateSnapshot !== null
+        && Array.isArray(stateSnapshot.todos);
+}
+function hasPlanToolEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.toolName === "write_todos" || item.toolName === "read_todos");
+}
+function hasExecutionToolEvidence(executedToolResults) {
+    return executedToolResults.some((item) => item.isError !== true && item.toolName !== "write_todos" && item.toolName !== "read_todos");
+}
 function isPlaceholderTaskCompletion(value) {
     const normalized = sanitizeVisibleText(value).trim();
     return normalized === "Task completed";
@@ -231,6 +242,17 @@ function looksLikeNonEvidenceApology(value) {
         || /(?:system limitation|technical limitation|internal limitation|recursion limit)/iu.test(normalized)
         || /(?:抱歉|对不起)[\s\S]*(?:无法|不能|未能)(?:完成|继续|处理)/u.test(normalized);
 }
+function looksLikeContradictedToolExecutionFailure(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (!normalized) {
+        return false;
+    }
+    const mentionsToolExecution = /(?:\btool\b|\bfunction\b|\bexecute\b|\binvoke\b|\bcall\b|工具|函数|调用|执行)/iu.test(normalized);
+    if (!mentionsToolExecution) {
+        return false;
+    }
+    return /(?:cancelled|canceled|timeout|timed out|race condition|cannot execute|can't execute|unable to execute|could not execute|failed to execute|被取消|超时|无法执行|不能执行|未能执行)/iu.test(normalized);
+}
 function extractDeterministicToolFailureReport(executedToolResults) {
     const hasSuccessfulSubstantiveTool = executedToolResults.some((toolResult) => (toolResult.isError !== true
         && toolResult.toolName !== "write_todos"
@@ -300,6 +322,9 @@ export function resolveDeterministicFinalOutput(params) {
         && (looksLikeClarificationQuestion(sanitizedVisibleOutput) || looksLikeNonEvidenceApology(sanitizedVisibleOutput))) {
         return deterministicFailureReport || delegatedTaskOutput || successfulToolOutput || sanitizedVisibleOutput;
     }
+    if (sanitizedVisibleOutput && successfulToolOutput && looksLikeContradictedToolExecutionFailure(sanitizedVisibleOutput)) {
+        return delegatedTaskOutput || successfulToolOutput;
+    }
     if (sanitizedVisibleOutput && !isLowSignalStructuredCompletion(sanitizedVisibleOutput)) {
         return sanitizedVisibleOutput;
     }
@@ -357,6 +382,10 @@ export function finalizeRequestResult(params) {
     const stateSnapshot = buildStateSnapshot(result);
     const hasIncompleteRequiredPlan = binding?.harnessRuntime?.executionContract?.requiresPlan === true
         && hasIncompleteStateSnapshotPlan(stateSnapshot);
+    const hasMissingRequiredPlanEvidence = binding?.harnessRuntime?.executionContract?.requiresPlan === true
+        && !hasStateSnapshotPlan(stateSnapshot)
+        && !hasPlanToolEvidence(allExecutedToolResults)
+        && !hasExecutionToolEvidence(allExecutedToolResults);
     const serializedResult = JSON.stringify(result, null, 2);
     let output = resolveDeterministicFinalOutput({
         visibleOutput,
@@ -368,8 +397,12 @@ export function finalizeRequestResult(params) {
     const hasMissingRequiredFinalAnswer = binding?.harnessRuntime?.executionContract?.requiresPlan === true
         && !visibleOutput
         && !preliminaryTerminalStatus
+        && !output.trim()
         && allExecutedToolResults.some((toolResult) => toolResult.isError !== true && toolResult.toolName !== "write_todos" && toolResult.toolName !== "read_todos");
-    if (hasIncompleteRequiredPlan && !visibleOutput) {
+    if (hasMissingRequiredPlanEvidence) {
+        output = "runtime_error=Agent ended before producing required plan evidence.";
+    }
+    else if (hasIncompleteRequiredPlan && !visibleOutput) {
         output = "runtime_error=Agent ended while required plan still had unfinished work.";
     }
     else if (hasMissingRequiredFinalAnswer) {
@@ -386,7 +419,7 @@ export function finalizeRequestResult(params) {
         agentId: bindingAgentId,
         state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0
             ? "waiting_for_approval"
-            : (hasIncompleteRequiredPlan && !hasSubstantiveFinalOutput) || hasMissingRequiredFinalAnswer
+            : hasMissingRequiredPlanEvidence || (hasIncompleteRequiredPlan && !hasSubstantiveFinalOutput) || hasMissingRequiredFinalAnswer
                 ? "failed"
                 : hasTerminalToolBlocker
                     ? "failed"

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

@@ -2,6 +2,7 @@ import path from "node:path";
 import { createAsyncSubAgentMiddleware, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { salvageJsonToolCalls } from "./parsing/output-tool-args.js";
 import { extractMessageText } from "../utils/message-content.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildDeepAgentSystemPromptWithCapabilityHierarchy, 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";
@@ -9,6 +10,7 @@ import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION } from "./prompts/runtim
 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 { 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";
 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 { isEmptyFinalAiMessageError, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
@@ -105,12 +107,77 @@ function parseFirstJsonObject(value) {
     }
     return null;
 }
+function parseCompactRouterSelection(value, subagentNames) {
+    const trimmed = value.trim();
+    if (subagentNames.has(trimmed)) {
+        return { subagentType: trimmed };
+    }
+    const parsed = parseFirstJsonObject(trimmed);
+    const toolCall = salvageJsonToolCalls(trimmed).at(0);
+    const payload = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+        ? parsed
+        : toolCall
+            ? { name: toolCall.name, arguments: toolCall.args }
+            : null;
+    if (!payload) {
+        return null;
+    }
+    const args = typeof payload.arguments === "object" && payload.arguments !== null && !Array.isArray(payload.arguments)
+        ? payload.arguments
+        : typeof payload.args === "object" && payload.args !== null && !Array.isArray(payload.args)
+            ? payload.args
+            : payload;
+    const subagentType = typeof payload.subagent_type === "string"
+        ? payload.subagent_type.trim()
+        : typeof args.subagent_type === "string"
+            ? args.subagent_type.trim()
+            : "";
+    if (subagentNames.has(subagentType)) {
+        return { subagentType };
+    }
+    const status = typeof payload.status === "string" ? payload.status.trim().toLowerCase() : "";
+    if (status === "refused") {
+        const reason = typeof payload.reason === "string" && payload.reason.trim()
+            ? payload.reason.trim()
+            : "No configured subagent can handle the request.";
+        return { refusedReason: reason };
+    }
+    return null;
+}
 function isDelegationOnlyDeepAgentBinding(binding) {
     return isDeepAgentBinding(binding)
         && getBindingSubagents(binding).length > 0
         && getBindingPrimaryTools(binding).length === 0
         && getBindingSkills(binding).length === 0;
 }
+function hasDelegatedPlanEvidence(result) {
+    const toolResults = result?.metadata?.executedToolResults;
+    return Array.isArray(toolResults)
+        && toolResults.some((item) => item.toolName === "write_todos" || item.toolName === "read_todos");
+}
+function resolveDelegatedResultOutput(result) {
+    const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
+        ? result.metadata.executedToolResults
+        : [];
+    const deterministicOutput = resolveDeterministicFinalOutput({
+        visibleOutput: typeof result.output === "string" ? result.output : "",
+        executedToolResults,
+    });
+    return deterministicOutput || result.output;
+}
+function selectDelegatedToolResultsForVisibleProgress(result) {
+    const executedToolResults = Array.isArray(result?.metadata?.executedToolResults)
+        ? result.metadata.executedToolResults
+        : [];
+    const hasSuccessfulExecutionEvidence = executedToolResults.some((toolResult) => (toolResult.isError !== true
+        && toolResult.toolName !== "write_todos"
+        && toolResult.toolName !== "read_todos"));
+    return hasSuccessfulExecutionEvidence
+        ? executedToolResults.filter((toolResult) => (toolResult.isError !== true
+            && toolResult.toolName !== "write_todos"
+            && toolResult.toolName !== "read_todos"))
+        : executedToolResults;
+}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -742,6 +809,7 @@ export class AgentRuntimeAdapter {
             return null;
         }
         const subagents = getBindingSubagents(binding);
+        const subagentNames = new Set(subagents.map((subagent) => subagent.name));
         const subagentCatalog = subagents
             .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
             .join("\n");
@@ -762,7 +830,7 @@ export class AgentRuntimeAdapter {
         if (typeof model.invoke !== "function") {
             return null;
         }
-        const raw = await this.invokeWithProviderRetry(binding, () => this.withTimeout(() => model.invoke(prompt, resolveLangChainInvocationConfig(binding, {
+        const invokeRouter = async (activePrompt, operationName) => this.invokeWithProviderRetry(binding, () => this.withTimeout(() => model.invoke(activePrompt, resolveLangChainInvocationConfig(binding, {
             sessionId,
             requestId,
             context: options.context,
@@ -771,28 +839,104 @@ export class AgentRuntimeAdapter {
                 sessionId,
                 requestId,
             }),
-        })), resolveBindingTimeout(binding), "delegation router invoke", "invoke"));
-        const parsed = parseFirstJsonObject(readModelText(raw));
-        if (typeof parsed !== "object" || parsed === null) {
-            return null;
+        })), resolveBindingTimeout(binding), operationName, "invoke"));
+        const routerPrompts = [
+            prompt,
+            [
+                prompt,
+                "Your previous router output was invalid.",
+                "Return only one JSON object now. Do not include prose, markdown, labels, or tool-call wrappers.",
+            ].join("\n\n"),
+            [
+                primaryModel.init?.think === false ? "/no_think" : "",
+                "Select one subagent from this exact list:",
+                Array.from(subagentNames).join(", "),
+                "Return JSON only:",
+                "{\"subagent_type\":\"<one exact listed name>\"}",
+                "User request:",
+                requestText,
+            ].filter(Boolean).join("\n\n"),
+            [
+                primaryModel.init?.think === false ? "/no_think" : "",
+                "JSON only. Pick a listed subagent or refuse.",
+                "Listed subagents:",
+                Array.from(subagentNames).join(", "),
+                "Allowed outputs:",
+                "{\"subagent_type\":\"<listed name>\"}",
+                "{\"status\":\"refused\",\"reason\":\"No configured subagent can handle the request.\"}",
+                "Request:",
+                requestText,
+            ].filter(Boolean).join("\n\n"),
+        ];
+        let selection = null;
+        let previousRawText = "";
+        for (let index = 0; index < routerPrompts.length && !selection; index += 1) {
+            const activePrompt = index <= 1 || !previousRawText
+                ? routerPrompts[index]
+                : [routerPrompts[index], "Previous output:", previousRawText].join("\n\n");
+            const raw = await invokeRouter(activePrompt, index === 0 ? "delegation router invoke" : `delegation router retry invoke ${index}`);
+            previousRawText = readModelText(raw);
+            selection = parseCompactRouterSelection(previousRawText, subagentNames);
         }
-        const subagentType = typeof parsed.subagent_type === "string"
-            ? parsed.subagent_type
-            : "";
-        if (!subagents.some((subagent) => subagent.name === subagentType)) {
+        if (selection?.refusedReason) {
+            return {
+                toolOutput: selection.refusedReason,
+                delegatedResult: {
+                    sessionId,
+                    requestId,
+                    agentId: binding.agent.id,
+                    state: "failed",
+                    output: selection.refusedReason,
+                    finalMessageText: selection.refusedReason,
+                },
+            };
+        }
+        const subagentType = selection?.subagentType ?? "";
+        if (!subagentNames.has(subagentType)) {
             return null;
         }
         const selectedBinding = this.options.bindingResolver(subagentType);
         if (!selectedBinding) {
             return null;
         }
-        const delegatedResult = await this.invoke(selectedBinding, requestText, sessionId, `${requestId}:${subagentType}`, undefined, [], {
+        const runDelegatedRequest = (text, requestSuffix = "") => this.invoke(selectedBinding, text, sessionId, `${requestId}:${subagentType}${requestSuffix}`, undefined, [], {
             context: options.context,
             state: options.state,
             files: options.files,
             memoryContext: options.memoryContext,
         });
-        return { toolOutput: delegatedResult.output, delegatedResult };
+        let delegatedResult = await runDelegatedRequest(requestText);
+        const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
+        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+            delegatedResult = await runDelegatedRequest([requestText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry");
+        }
+        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+            const output = `runtime_error=Delegated agent ${selectedBinding.agent.id} completed without tool execution evidence.`;
+            return {
+                toolOutput: output,
+                delegatedResult: {
+                    ...delegatedResult,
+                    state: "failed",
+                    output,
+                    finalMessageText: output,
+                },
+            };
+        }
+        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
+            && !hasDelegatedPlanEvidence(delegatedResult)
+            && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+            const output = "runtime_error=Delegated agent ended before producing required plan evidence.";
+            return {
+                toolOutput: output,
+                delegatedResult: {
+                    ...delegatedResult,
+                    state: "failed",
+                    output,
+                    finalMessageText: output,
+                },
+            };
+        }
+        return { toolOutput: resolveDelegatedResultOutput(delegatedResult), delegatedResult };
     }
     async *stream(binding, input, sessionId, history = [], options = {}) {
         const directListing = await this.tryHandleDirectWorkspaceListing(binding, input, {
@@ -812,17 +956,32 @@ export class AgentRuntimeAdapter {
             };
             return;
         }
+        if (isDelegationOnlyDeepAgentBinding(binding)) {
+            yield {
+                kind: "commentary",
+                content: "Selecting a specialist for delegated execution.",
+            };
+        }
         const compactDelegation = await this.tryDelegateWithCompactRouter(binding, input, sessionId, options.requestId ?? sessionId, {
             ...options,
             sessionId,
             requestId: options.requestId,
         });
         if (compactDelegation) {
+            const delegatedToolResults = selectDelegatedToolResultsForVisibleProgress(compactDelegation.delegatedResult);
             yield {
                 kind: "tool-result",
                 toolName: "task",
                 output: compactDelegation.toolOutput,
             };
+            for (const toolResult of delegatedToolResults) {
+                yield {
+                    kind: "tool-result",
+                    toolName: toolResult.toolName,
+                    output: toolResult.output,
+                    isError: toolResult.isError,
+                };
+            }
             yield {
                 kind: "content",
                 content: typeof compactDelegation.toolOutput === "string"

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

@@ -1,5 +1,5 @@
 import { AIMessage } from "langchain";
-import { salvageFunctionLikeToolCall, salvageJsonToolCalls, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
+import { salvageFunctionLikeToolCall, salvageJsonToolCalls, salvageLabeledToolCall, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
 function consumeLeadingFunctionLikeToolCall(value) {
     const match = /^([A-Za-z_][A-Za-z0-9_]*)\(/.exec(value);
     if (!match) {
@@ -59,6 +59,9 @@ function consumeLeadingFunctionLikeToolCall(value) {
 function stripVisibleFunctionLikeToolCallText(value) {
     let remaining = value.trim();
     let removedLeadingCall = false;
+    if (salvageLabeledToolCall(remaining)) {
+        return "";
+    }
     if (salvageJsonToolCalls(remaining).length > 0) {
         return "";
     }
@@ -88,6 +91,7 @@ function stripVisibleFunctionLikeToolCallText(value) {
 export function sanitizeVisibleText(value) {
     return stripVisibleFunctionLikeToolCallText(value
         .replace(/<agent_memory>[\s\S]*?<\/agent_memory>/giu, "")
+        .replace(/<agent_memory>[\s\S]*$/giu, "")
         .replace(/[A-Za-z0-9_]*Middleware\.after_model/g, "")
         .replace(/todoListMiddleware\.after_model/g, "")
         .replace(/__end__+/g, "")
@@ -499,10 +503,13 @@ function normalizeAgentMessage(value) {
     const functionLikeToolCall = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && typeof normalizedContent === "string"
         ? salvageFunctionLikeToolCall(normalizedContent)
         : null;
-    const jsonToolCalls = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && !functionLikeToolCall && typeof normalizedContent === "string"
+    const labeledToolCall = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && !functionLikeToolCall && typeof normalizedContent === "string"
+        ? salvageLabeledToolCall(normalizedContent)
+        : null;
+    const jsonToolCalls = normalizedToolCalls.length === 0 && recoveredToolCalls.length === 0 && !functionLikeToolCall && !labeledToolCall && typeof normalizedContent === "string"
         ? salvageJsonToolCalls(normalizedContent)
         : [];
-    const hasRecoveredContentToolCalls = Boolean(functionLikeToolCall) || jsonToolCalls.length > 0;
+    const hasRecoveredContentToolCalls = Boolean(functionLikeToolCall) || Boolean(labeledToolCall) || jsonToolCalls.length > 0;
     return new AIMessage({
         content: hasRecoveredContentToolCalls ? "" : normalizedContent,
         name: typeof typed.name === "string" ? typed.name : undefined,
@@ -513,6 +520,7 @@ function normalizeAgentMessage(value) {
             ...normalizedToolCalls,
             ...recoveredToolCalls,
             ...(functionLikeToolCall ? [{ name: functionLikeToolCall.name, args: functionLikeToolCall.args }] : []),
+            ...(labeledToolCall ? [{ name: labeledToolCall.name, args: labeledToolCall.args }] : []),
             ...jsonToolCalls.map((toolCall) => ({ name: toolCall.name, args: toolCall.args })),
         ],
         invalid_tool_calls: normalizedInvalidToolCalls.filter((toolCall) => toolCall.type !== "tool_call"),

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

@@ -3,6 +3,10 @@ export declare function salvageFunctionLikeToolCall(value: unknown): {
     name: string;
     args: Record<string, unknown>;
 } | null;
+export declare function salvageLabeledToolCall(value: unknown): {
+    name: string;
+    args: Record<string, unknown>;
+} | null;
 export declare function salvageToolArgs(value: unknown): Record<string, unknown> | null;
 export declare function salvageJsonToolCalls(value: unknown): Array<{
     name: string;

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

@@ -112,6 +112,73 @@ export function salvageFunctionLikeToolCall(value) {
     }
     return { name, args: normalizeKnownToolArgs(name, args) };
 }
+function normalizeFieldLabel(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .split("")
+        .filter((char) => {
+        const code = char.charCodeAt(0);
+        return (code >= 97 && code <= 122) || (code >= 48 && code <= 57);
+    })
+        .join("");
+}
+function splitLabeledLine(line) {
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex <= 0) {
+        return null;
+    }
+    const label = normalizeFieldLabel(line.slice(0, separatorIndex));
+    const value = line.slice(separatorIndex + 1).trim();
+    return label ? { label, value } : null;
+}
+function isToolName(value) {
+    if (!value) {
+        return false;
+    }
+    const first = value.charCodeAt(0);
+    if (!((first >= 65 && first <= 90) || (first >= 97 && first <= 122) || first === 95)) {
+        return false;
+    }
+    for (let index = 1; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (!((code >= 65 && code <= 90) || (code >= 97 && code <= 122) || (code >= 48 && code <= 57) || code === 95)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isToolNameLabel(label) {
+    return label === "toolcall" || label === "tool" || label === "functioncall" || label === "function";
+}
+function isToolArgsLabel(label) {
+    return label === "arguments" || label === "args" || label === "parameters" || label === "input";
+}
+export function salvageLabeledToolCall(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const lines = value
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (let index = 0; index < lines.length; index += 1) {
+        const toolLine = splitLabeledLine(lines[index]);
+        if (!toolLine || !isToolNameLabel(toolLine.label) || !isToolName(toolLine.value)) {
+            continue;
+        }
+        for (let argsIndex = index + 1; argsIndex < lines.length; argsIndex += 1) {
+            const argsLine = splitLabeledLine(lines[argsIndex]);
+            if (!argsLine || !isToolArgsLabel(argsLine.label)) {
+                continue;
+            }
+            const argsText = [argsLine.value, ...lines.slice(argsIndex + 1)].filter(Boolean).join("\n").trim();
+            const args = salvageToolArgs(argsText) ?? {};
+            return { name: toolLine.value, args: normalizeKnownToolArgs(toolLine.value, args) };
+        }
+    }
+    return null;
+}
 function extractBalancedJsonValue(value, openChar, closeChar) {
     const start = value.indexOf(openChar);
     if (start < 0)
@@ -306,16 +373,16 @@ export function salvageJsonToolCalls(value) {
                     return parsed;
                 }
             }
-            const embeddedArray = extractBalancedJsonArray(trimmed);
-            if (embeddedArray) {
-                const parsed = tryParseJson(embeddedArray);
+            const embeddedObject = extractBalancedJsonObject(trimmed);
+            if (embeddedObject) {
+                const parsed = tryParseJson(embeddedObject);
                 if (parsed) {
                     return parsed;
                 }
             }
-            const embeddedObject = extractBalancedJsonObject(trimmed);
-            if (embeddedObject) {
-                const parsed = tryParseJson(embeddedObject);
+            const embeddedArray = extractBalancedJsonArray(trimmed);
+            if (embeddedArray) {
+                const parsed = tryParseJson(embeddedArray);
                 if (parsed) {
                     return parsed;
                 }
@@ -334,7 +401,7 @@ function normalizeWriteTodosArgs(args) {
     }
     return {
         ...args,
-        todos: args.todos.map((todo) => {
+        todos: args.todos.map((todo, index) => {
             if (typeof todo !== "object" || !todo || Array.isArray(todo)) {
                 return todo;
             }
@@ -343,7 +410,7 @@ function normalizeWriteTodosArgs(args) {
                 ? record.content
                 : typeof record.description === "string" && record.description.trim().length > 0
                     ? record.description
-                    : undefined;
+                    : `Step ${index + 1}`;
             const normalized = {};
             if (content !== undefined)
                 normalized.content = content;

package/package.json

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