@botbotgo/agent-harness 0.0.419 → 0.0.421

package/dist/cli/chat-interactive.js

@@ -166,7 +166,7 @@ export async function runInteractiveChatLoop(input) {
                 }
                 activeSessionId = chatCommand.arg;
                 latestRequestId = session.latestRequestId;
-                activeAgentId = session.currentAgentId ?? session.entryAgentId ?? activeAgentId;
+                activeAgentId = session.entryAgentId ?? session.currentAgentId ?? activeAgentId;
                 input.stdout(`session=${activeSessionId}\n`);
                 continue;
             }

package/dist/cli/chat-stream.js

@@ -10,6 +10,7 @@ export async function streamChatMessage(input) {
     let latestSessionId = input.sessionId;
     let latestRequestId;
     let latestAgentId = input.agentId;
+    let entryAgentId = input.agentId;
     let wroteContent = false;
     let wroteRenderableBlocks = false;
     let renderedAssistantOutput = "";
@@ -348,6 +349,7 @@ export async function streamChatMessage(input) {
         writeChatStderr(lines.join(""));
     };
     const renderContentBlocks = (contentBlocks, agentId) => {
+        entryAgentId ??= agentId;
         latestAgentId = agentId || latestAgentId;
         const rendered = contentBlocks
             .map((block) => {
@@ -373,6 +375,7 @@ export async function streamChatMessage(input) {
             markRuntimeProgress();
             latestSessionId = snapshot.sessionId || latestSessionId;
             latestRequestId = snapshot.requestId || latestRequestId;
+            entryAgentId ??= snapshot.agentId;
             latestAgentId = snapshot.agentId || latestAgentId;
             latestSnapshot = snapshot;
             firstSnapshotAt ??= Date.now();
@@ -421,16 +424,19 @@ export async function streamChatMessage(input) {
             latestRequestId = delta.requestId || latestRequestId;
             firstDataAt ??= Date.now();
             if (delta.type === "output.text.delta") {
+                entryAgentId ??= delta.agentId;
                 latestAgentId = delta.agentId || latestAgentId;
                 writeAssistantOutput(delta.text);
                 return;
             }
             if (delta.type === "output.content-blocks") {
+                entryAgentId ??= delta.agentId;
                 suspendRequestTreeRendering();
                 renderContentBlocks(delta.contentBlocks, delta.agentId);
                 return;
             }
             if (delta.type === "plan.step") {
+                entryAgentId ??= delta.agentId;
                 latestAgentId = delta.agentId || latestAgentId;
                 const item = delta.item;
                 const status = typeof item?.status === "string" ? item.status : "unknown";
@@ -441,6 +447,7 @@ export async function streamChatMessage(input) {
                 return;
             }
             if (delta.type === "tool.result") {
+                entryAgentId ??= delta.agentId;
                 latestAgentId = delta.agentId || latestAgentId;
                 if ((input.showToolResults ?? true) && !input.requestEvents) {
                     writeChatStderr(`\n[${formatPerfClock(Date.now())} +${formatElapsed(Date.now())}]${formatAgentProgressLabel(delta.agentId)} [tool:${delta.toolName}] ${summarizeChatToolResult(delta.output, delta.isError === true)}${delta.isError ? " (error)" : ""}\n`);
@@ -448,6 +455,7 @@ export async function streamChatMessage(input) {
                 return;
             }
             if (delta.type === "progress.commentary") {
+                entryAgentId ??= delta.agentId;
                 latestAgentId = delta.agentId || latestAgentId;
                 if (wroteContent || wroteRenderableBlocks) {
                     return;
@@ -500,5 +508,5 @@ export async function streamChatMessage(input) {
         writeChatStdout("\n");
     }
     await Promise.allSettled([stdoutWriteChain, stderrWriteChain]);
-    return { sessionId: latestSessionId, requestId: latestRequestId, agentId: latestAgentId };
+    return { sessionId: latestSessionId, requestId: latestRequestId, agentId: entryAgentId ?? latestAgentId };
 }

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.419";
-export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-02";
+export declare const AGENT_HARNESS_VERSION = "0.0.421";
+export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-03";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.419";
-export const AGENT_HARNESS_RELEASE_DATE = "2026-05-02";
+export const AGENT_HARNESS_VERSION = "0.0.421";
+export const AGENT_HARNESS_RELEASE_DATE = "2026-05-03";

package/dist/runtime/adapter/flow/invocation-flow.d.ts

@@ -16,6 +16,16 @@ export declare function executeRequestInvocation(options: {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
+        externalPlanEvidenceTool?: {
+            name: string;
+            args?: Record<string, unknown>;
+            id?: string;
+        };
+        externalPlanEvidenceTools?: Array<{
+            name: string;
+            args?: Record<string, unknown>;
+            id?: string;
+        }>;
     };
     resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
     getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;

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

@@ -339,6 +339,8 @@ export async function executeRequestInvocation(options) {
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
         toolRuntimeContext: invokeOptions.toolRuntimeContext,
         externalPlanEvidence: invokeOptions.externalPlanEvidence,
+        externalPlanEvidenceTool: invokeOptions.externalPlanEvidenceTool,
+        externalPlanEvidenceTools: invokeOptions.externalPlanEvidenceTools,
     });
     let localOrUpstreamInvocation = await invokeOnce(request);
     if (options.resumePayload === undefined

package/dist/runtime/adapter/flow/invoke-runtime.d.ts

@@ -18,6 +18,16 @@ export declare function invokeRuntimeWithLocalTools(options: {
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
     toolRuntimeContext?: Record<string, unknown>;
     externalPlanEvidence?: boolean;
+    externalPlanEvidenceTool?: {
+        name: string;
+        args?: Record<string, unknown>;
+        id?: string;
+    };
+    externalPlanEvidenceTools?: Array<{
+        name: string;
+        args?: Record<string, unknown>;
+        id?: string;
+    }>;
 }): Promise<{
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];

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

@@ -16,5 +16,7 @@ export async function invokeRuntimeWithLocalTools(options) {
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
         toolRuntimeContext: options.toolRuntimeContext,
         externalPlanEvidence: options.externalPlanEvidence,
+        externalPlanEvidenceTool: options.externalPlanEvidenceTool,
+        externalPlanEvidenceTools: options.externalPlanEvidenceTools,
     });
 }

package/dist/runtime/adapter/flow/stream-runtime.d.ts

@@ -23,6 +23,16 @@ export declare function streamRuntimeExecution(options: {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
+        externalPlanEvidenceTool?: {
+            name: string;
+            args?: Record<string, unknown>;
+            id?: string;
+        };
+        externalPlanEvidenceTools?: Array<{
+            name: string;
+            args?: Record<string, unknown>;
+            id?: string;
+        }>;
     };
     primaryTools: CompiledTool[];
     toolNameMapping: ToolNameMapping;
@@ -51,6 +61,16 @@ export declare function streamRuntimeExecution(options: {
         toolRuntimeContext?: Record<string, unknown>;
         suppressInitialRequiredPlanInstruction?: boolean;
         externalPlanEvidence?: boolean;
+        externalPlanEvidenceTool?: {
+            name: string;
+            args?: Record<string, unknown>;
+            id?: string;
+        };
+        externalPlanEvidenceTools?: Array<{
+            name: string;
+            args?: Record<string, unknown>;
+            id?: string;
+        }>;
     }) => Promise<{
         output: string;
         metadata?: Record<string, unknown>;

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

@@ -128,6 +128,182 @@ function hasIncompletePlanOutput(value) {
     }
     return null;
 }
+function extractInProgressTodoContents(value) {
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+    const typed = value;
+    const arrays = [typed.todos, typed.items];
+    const contents = [];
+    for (const candidate of arrays) {
+        if (!Array.isArray(candidate)) {
+            continue;
+        }
+        for (const todo of candidate) {
+            if (typeof todo !== "object" || todo === null) {
+                continue;
+            }
+            const item = todo;
+            if (item.status !== "in_progress") {
+                continue;
+            }
+            const content = [item.content, item.description, item.title, item.name, item.text]
+                .find((value) => typeof value === "string" && value.trim().length > 0);
+            if (content) {
+                contents.push(content.trim());
+            }
+        }
+    }
+    for (const nested of [typed.summary, typed.update, typed.data, typed.output]) {
+        contents.push(...extractInProgressTodoContents(nested));
+    }
+    return [...new Set(contents)];
+}
+function extractTodoContentsForEvidenceResolution(value) {
+    const inProgress = extractTodoContentsByStatus(value, "in_progress");
+    if (inProgress.length > 0) {
+        return inProgress;
+    }
+    return extractTodoContentsByStatus(value, "pending");
+}
+function extractTodoContentsByStatus(value, status) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => extractTodoContentsByStatus(item, status));
+    }
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+    const typed = value;
+    const arrays = [typed.todos, typed.items];
+    const contents = [];
+    for (const array of arrays) {
+        if (!Array.isArray(array)) {
+            continue;
+        }
+        for (const item of array) {
+            if (typeof item !== "object" || item === null) {
+                continue;
+            }
+            const typedItem = item;
+            if (typedItem.status !== status) {
+                continue;
+            }
+            const content = [
+                typedItem.content,
+                typedItem.description,
+                typedItem.title,
+                typedItem.name,
+                typedItem.text,
+            ].find((value) => typeof value === "string" && value.trim().length > 0);
+            if (content) {
+                contents.push(content.trim());
+            }
+        }
+    }
+    for (const nested of [typed.summary, typed.update, typed.data, typed.output]) {
+        contents.push(...extractTodoContentsByStatus(nested, status));
+    }
+    return [...new Set(contents)];
+}
+function buildRunCommittedTodoEvidenceInstruction(primaryTools, planToolOutput) {
+    const todoContents = extractInProgressTodoContents(planToolOutput);
+    const todoText = todoContents.length > 0
+        ? todoContents.map((content, index) => `${index + 1}. ${content}`).join("\n")
+        : "(no in-progress todo content was readable)";
+    return [
+        buildRunEvidenceAfterPlanInstruction(primaryTools),
+        "",
+        "The completed write_todos result contains these in-progress evidence commitments:",
+        todoText,
+        "",
+        "Your next action must execute the non-planning tool named by the in-progress TODO. If every TODO is pending, execute the non-planning tool named by the first pending TODO. Do not call write_todos or read_todos again before that evidence tool returns.",
+    ].join("\n");
+}
+function resolveCommittedPlanEvidenceTool(primaryTools, planToolOutput) {
+    return resolveCommittedPlanEvidenceTools(primaryTools, planToolOutput)[0];
+}
+function resolveCommittedPlanEvidenceTools(primaryTools, planToolOutput) {
+    const availableToolNames = primaryTools
+        .map(readPrimaryToolName)
+        .filter((name) => name.length > 0 && !isPlanToolName(name));
+    const todoContents = extractTodoContentsForEvidenceResolution(planToolOutput);
+    if (todoContents.length === 0) {
+        return [];
+    }
+    const toolsByName = new Map(primaryTools.map((tool) => [tool.name, tool]));
+    const resolved = [];
+    const seen = new Set();
+    for (const content of todoContents) {
+        const todoText = content.toLowerCase();
+        const matches = availableToolNames.filter((name) => todoText.includes(name.toLowerCase()));
+        const selectedNames = matches.length === 1
+            ? [matches[0]]
+            : resolveBestScoredToolNames(availableToolNames, toolsByName, todoText);
+        for (const selectedName of selectedNames) {
+            if (seen.has(selectedName)) {
+                continue;
+            }
+            seen.add(selectedName);
+            const matchedTool = toolsByName.get(selectedName);
+            const args = buildCommittedPlanEvidenceToolArgs(matchedTool, content);
+            resolved.push({
+                name: selectedName,
+                args,
+                id: `stream-committed-plan-evidence-tool-${resolved.length + 1}`,
+            });
+        }
+    }
+    return resolved;
+}
+function extractSelectionTokens(value) {
+    const tokens = new Set();
+    for (const match of value.matchAll(/[\p{L}\p{N}_-]+/gu)) {
+        const token = match[0].toLowerCase();
+        if (token.length >= 2) {
+            tokens.add(token);
+        }
+        for (const part of token.split(/[_-]+/u)) {
+            if (part.length >= 2) {
+                tokens.add(part);
+            }
+        }
+    }
+    return tokens;
+}
+function resolveBestScoredToolNames(availableToolNames, toolsByName, todoText) {
+    const requestTokens = extractSelectionTokens(todoText);
+    const scored = availableToolNames
+        .map((name) => {
+        const tool = toolsByName.get(name);
+        const toolTokens = extractSelectionTokens(`${name} ${tool?.description ?? ""}`);
+        const toolNameTokens = extractSelectionTokens(name);
+        let score = 0;
+        for (const token of requestTokens) {
+            if (toolNameTokens.has(token)) {
+                score += 10;
+                continue;
+            }
+            if (toolTokens.has(token)) {
+                score += token.length > 3 ? 2 : 1;
+            }
+        }
+        return { name, score };
+    })
+        .filter((item) => item.score > 0)
+        .sort((left, right) => right.score - left.score);
+    const topScore = scored[0]?.score ?? 0;
+    return topScore > 0 ? scored.filter((item) => item.score === topScore).map((item) => item.name) : [];
+}
+function buildCommittedPlanEvidenceToolArgs(tool, todoText) {
+    const properties = typeof tool?.modelSchema === "object" && tool.modelSchema !== null
+        ? tool.modelSchema.properties
+        : undefined;
+    if (typeof properties !== "object" || properties === null) {
+        return {};
+    }
+    const queryLikeField = ["query", "question", "prompt", "input", "text"].find((field) => Object.prototype.hasOwnProperty.call(properties, field));
+    return queryLikeField ? { [queryLikeField]: todoText } : {};
+}
 function normalizePlanToolName(toolName) {
     return typeof toolName === "string" ? toolName.trim().toLowerCase().replace(/[\s-]+/gu, "_") : "";
 }
@@ -655,6 +831,7 @@ export async function* streamRuntimeExecution(options) {
                     let sawCompletedPlanToolResult = false;
                     let sawSuccessfulNonTodoToolResult = false;
                     let earlyStreamRecoveryInstruction = null;
+                    let earlyStreamExternalPlanEvidenceTools;
                     let earlyStreamRecoverySuppressInitialPlan = false;
                     let completedPlanToolResultCount = 0;
                     for await (const event of options.iterateWithTimeout(events, options.streamIdleTimeoutMs, "agent streamEvents", options.streamDeadlineAt, options.invokeTimeoutMs)) {
@@ -677,12 +854,15 @@ export async function* streamRuntimeExecution(options) {
                             && chunk.kind !== "content"
                             && !(chunk.kind === "tool-result" && isPlanToolName(chunk.toolName))
                             && !(chunk.kind === "tool-result" && chunk.isError === true && isRetrySafeInvalidToolSelectionError(chunk.output)));
+                        const hadPriorPlanToolResult = completedPlanToolResultCount > 0;
                         const repeatedPlanToolResultBeforeEvidence = requiresPlanEvidence(options.binding)
                             && !sawSuccessfulNonTodoToolResult
-                            && completedPlanToolResultCount > 0
+                            && hadPriorPlanToolResult
                             && projectedChunks.some((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName));
                         if (repeatedPlanToolResultBeforeEvidence) {
-                            earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
+                            const planToolResult = projectedChunks.find((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName) && chunk.isError !== true);
+                            earlyStreamExternalPlanEvidenceTools = resolveCommittedPlanEvidenceTools(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
+                            earlyStreamRecoveryInstruction = buildRunCommittedTodoEvidenceInstruction(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
                         }
@@ -721,6 +901,18 @@ export async function* streamRuntimeExecution(options) {
                             }
                             yield chunk;
                         }
+                        const eventContainsPlanToolResult = projectedChunks.some((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName) && chunk.isError !== true);
+                        if (requiresPlanEvidence(options.binding)
+                            && eventContainsPlanToolResult
+                            && (hadPriorPlanToolResult
+                                || projectedChunks.some((chunk) => isCompletedPlanToolResultChunk(chunk)))
+                            && !sawSuccessfulNonTodoToolResult) {
+                            const planToolResult = projectedChunks.find((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName) && chunk.isError !== true);
+                            earlyStreamExternalPlanEvidenceTools = resolveCommittedPlanEvidenceTools(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
+                            earlyStreamRecoveryInstruction = buildRunCommittedTodoEvidenceInstruction(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
+                            earlyStreamRecoverySuppressInitialPlan = true;
+                            break;
+                        }
                         if (requiresPlanEvidence(options.binding) && sawCompletedPlanToolResult && sawSuccessfulNonTodoToolResult) {
                             if (hasUsefulVisibleSynthesis(projectionState.emittedOutput)) {
                                 if (deferredStreamContent.length > 0) {
@@ -794,7 +986,13 @@ export async function* streamRuntimeExecution(options) {
                     }
                     if (earlyStreamRecoveryInstruction) {
                         const earlyRecoveryRuntimeOptions = earlyStreamRecoverySuppressInitialPlan
-                            ? withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions)
+                            ? {
+                                ...withSuppressedInitialRequiredPlanInstruction(options.runtimeOptions),
+                                externalPlanEvidence: true,
+                                ...(earlyStreamExternalPlanEvidenceTools && earlyStreamExternalPlanEvidenceTools.length > 0
+                                    ? { externalPlanEvidenceTools: earlyStreamExternalPlanEvidenceTools }
+                                    : {}),
+                            }
                             : options.runtimeOptions;
                         const recovered = await options.invoke(options.applyToolRecoveryInstruction(options.binding, earlyStreamRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, earlyRecoveryRuntimeOptions);
                         const recoveredToolResults = Array.isArray(recovered.metadata?.executedToolResults)

package/dist/runtime/adapter/local-tool-invocation.d.ts

@@ -16,10 +16,20 @@ type LocalToolInvocationParams = {
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
     toolRuntimeContext?: Record<string, unknown>;
     externalPlanEvidence?: boolean;
+    externalPlanEvidenceTool?: {
+        name: string;
+        args?: Record<string, unknown>;
+        id?: string;
+    };
+    externalPlanEvidenceTools?: Array<{
+        name: string;
+        args?: Record<string, unknown>;
+        id?: string;
+    }>;
 };
 type LocalToolInvocationResult = {
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];
 };
-export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, externalPlanEvidence, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
+export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, externalPlanEvidence, externalPlanEvidenceTool, externalPlanEvidenceTools, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
 export {};