@botbotgo/agent-harness 0.0.355 → 0.0.359

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.355";
+export declare const AGENT_HARNESS_VERSION = "0.0.359";
 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.355";
+export const AGENT_HARNESS_VERSION = "0.0.359";
 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

@@ -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;
@@ -314,6 +317,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)

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";
@@ -357,6 +368,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,
@@ -369,7 +384,10 @@ export function finalizeRequestResult(params) {
         && !visibleOutput
         && !preliminaryTerminalStatus
         && 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 +404,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";
@@ -105,12 +106,54 @@ 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");
+}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -742,6 +785,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");
@@ -772,26 +816,86 @@ export class AgentRuntimeAdapter {
                 requestId,
             }),
         })), resolveBindingTimeout(binding), "delegation router invoke", "invoke"));
-        const parsed = parseFirstJsonObject(readModelText(raw));
-        if (typeof parsed !== "object" || parsed === null) {
-            return null;
+        const rawText = readModelText(raw);
+        let selection = parseCompactRouterSelection(rawText, subagentNames);
+        if (!selection) {
+            const retryPrompt = [
+                prompt,
+                "Your previous router output was invalid.",
+                "Previous output:",
+                rawText,
+                "Return only one JSON object now. Do not include prose, markdown, labels, or tool-call wrappers.",
+            ].join("\n\n");
+            const retryRaw = await this.invokeWithProviderRetry(binding, () => this.withTimeout(() => model.invoke(retryPrompt, resolveLangChainInvocationConfig(binding, {
+                sessionId,
+                requestId,
+                context: options.context,
+                toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
+                    ...options,
+                    sessionId,
+                    requestId,
+                }),
+            })), resolveBindingTimeout(binding), "delegation router retry invoke", "invoke"));
+            selection = parseCompactRouterSelection(readModelText(retryRaw), 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,
         });
+        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: delegatedResult.output, delegatedResult };
     }
     async *stream(binding, input, sessionId, history = [], options = {}) {

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.355",
+  "version": "0.0.359",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",
@@ -8,8 +8,8 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "agent-harness": "./dist/cli.js",
-    "botbotgo": "./dist/cli.js"
+    "agent-harness": "dist/cli.js",
+    "botbotgo": "dist/cli.js"
   },
   "files": [
     "dist"