@botbotgo/agent-harness 0.0.380 → 0.0.382

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.380";
-export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";
+export declare const AGENT_HARNESS_VERSION = "0.0.382";
+export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-01";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.380";
-export const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";
+export const AGENT_HARNESS_VERSION = "0.0.382";
+export const AGENT_HARNESS_RELEASE_DATE = "2026-05-01";

package/dist/projections/presentation.js

@@ -47,12 +47,32 @@ function renderMarkdownTable(block) {
     const columnCount = Math.max(header.length, ...body.map((row) => row.length));
     const normalizedRows = [header, ...body].map((row) => Array.from({ length: columnCount }, (_, index) => renderInlineConsoleMarkdown(row[index] ?? "")));
     const widths = Array.from({ length: columnCount }, (_, index) => Math.max(...normalizedRows.map((row) => stripAnsi(row[index] ?? "").length), 0));
+    const renderedWidth = widths.reduce((sum, width) => sum + width, 0) + (columnCount * 3) + 1;
+    if (renderedWidth > 120 || columnCount > 5) {
+        return renderMarkdownTableAsList(header, body);
+    }
     const renderRow = (row) => `| ${row
         .map((cell, index) => cell.padEnd(widths[index] + (cell.length - stripAnsi(cell).length)))
         .join(" | ")} |`;
     const separator = `|-${widths.map((width) => "-".repeat(Math.max(3, width))).join("-|-")}-|`;
     return [renderRow(normalizedRows[0] ?? []), separator, ...normalizedRows.slice(1).map(renderRow)].join("\n");
 }
+function renderMarkdownTableAsList(header, body) {
+    const normalizedHeader = header.map((cell) => cell.trim()).filter(Boolean);
+    return body
+        .map((row, rowIndex) => {
+        const title = renderInlineConsoleMarkdown(row[0]?.trim() || `Row ${rowIndex + 1}`);
+        const details = normalizedHeader.slice(1).flatMap((label, index) => {
+            const value = row[index + 1]?.trim();
+            if (!value) {
+                return [];
+            }
+            return `  • ${renderInlineConsoleMarkdown(label)}: ${renderInlineConsoleMarkdown(value)}`;
+        });
+        return [`• ${title}`, ...details].join("\n");
+    })
+        .join("\n\n");
+}
 export function markdownToHtml(markdown) {
     const normalized = markdown.replace(/\r\n/g, "\n");
     const blocks = normalized.split(/\n\n+/);
@@ -96,7 +116,10 @@ export function markdownToConsole(markdown) {
     if (!markdown.includes("\n")) {
         return renderInlineConsoleMarkdown(markdown.trim());
     }
-    const normalized = markdown.replace(/\r\n/g, "\n");
+    const normalized = markdown
+        .replace(/\r\n/g, "\n")
+        .replace(/^(#{1,6}\s+.+)$/gm, "\n$1\n")
+        .replace(/^(\s*[-*_=])(?:\s*\1){2,}\s*$/gm, "\n$&\n");
     const blocks = normalized.split(/\n\n+/);
     const rendered = [];
     for (const block of blocks) {
@@ -128,7 +151,8 @@ export function markdownToConsole(markdown) {
             const level = match?.[1].length ?? 1;
             const title = renderInlineConsoleMarkdown(match?.[2] ?? trimmed);
             const underline = level === 1 ? "=" : "-";
-            rendered.push(`\u001b[1m${title}\u001b[0m\n\u001b[2m${underline.repeat(Math.max(3, title.replace(/\u001b\[[0-9;]*m/g, "").length))}\u001b[0m`);
+            const underlineWidth = Math.min(72, Math.max(3, title.replace(/\u001b\[[0-9;]*m/g, "").length));
+            rendered.push(`\u001b[1m${title}\u001b[0m\n\u001b[2m${underline.repeat(underlineWidth)}\u001b[0m`);
             continue;
         }
         if (trimmed.split("\n").every((line) => /^\s*[-*]\s+/.test(line))) {
@@ -159,7 +183,7 @@ export function markdownToConsole(markdown) {
                 .join("\n"));
             continue;
         }
-        if (/^([-*_])(?:\s*\1){2,}$/.test(trimmed)) {
+        if (/^([-*_=])(?:\s*\1){2,}$/.test(trimmed)) {
             rendered.push(`\u001b[2m${"─".repeat(24)}\u001b[0m`);
             continue;
         }

package/dist/runtime/adapter/model/model-providers.js

@@ -489,6 +489,65 @@ function normalizeParsedToolCall(payload) {
         : salvageToolArgs(argsCandidate) ?? {};
     return { name, args };
 }
+function extractFallbackTodoContentsFromText(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return [];
+    }
+    const candidates = normalized
+        .split(/\r?\n/)
+        .map((line) => line
+        .replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+|\[[ x~!-]\]\s+)/i, "")
+        .replace(/^\s*(?:todo|step|task)\s*\d*\s*[:.-]\s*/i, "")
+        .trim())
+        .filter((line) => line.length >= 12
+        && !/^(?:status|summary|findings|blockers|next actions)\s*[:：]?$/i.test(line)
+        && !/\b(?:plan|todo|steps?)\s*[:：]\s*$/i.test(line)
+        && !isLowSignalPlanningLine(line));
+    const seen = new Set();
+    return candidates.filter((line) => {
+        const key = line.toLowerCase();
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    }).slice(0, 6);
+}
+function isLowSignalPlanningLine(value) {
+    const normalized = value.trim().toLowerCase();
+    return (normalized.length < 12
+        || /^#+\s*/.test(normalized)
+        || /^(?:ok|okay|sure|understood|got it|plan|todo|steps?)\.?$/.test(normalized));
+}
+function buildFallbackPlanningToolCall(input, tools, rawText) {
+    const toolName = tools.map((tool) => readBoundToolName(tool)).find((name) => name === "write_todos" || name === "tool_call_write_todos");
+    if (!toolName) {
+        return null;
+    }
+    const modelPlannedItems = extractFallbackTodoContentsFromText(rawText);
+    const fallbackItems = modelPlannedItems.length >= 2
+        ? modelPlannedItems
+        : [
+            "Gather concrete evidence for the requested investigation",
+            "Inspect the most relevant runtime signals and tool outputs",
+            "Analyze the evidence to identify root cause and impact",
+            "Produce the final RCA report with blockers and next actions",
+        ];
+    const todos = fallbackItems.map((content, index) => ({
+        content,
+        status: index === 0 ? "in_progress" : "pending",
+    }));
+    return new AIMessage({
+        content: "",
+        tool_calls: [{
+                id: `tool-${Math.random().toString(36).slice(2, 10)}`,
+                name: toolName,
+                args: { todos },
+                type: "tool_call",
+            }],
+    });
+}
 function formatBoundToolInstruction(tool) {
     if (typeof tool !== "object" || tool === null) {
         return null;
@@ -554,6 +613,12 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                     const text = readModelText(rawResult);
                     const parsedToolCall = normalizeParsedToolCall(extractToolCallPayload(text));
                     if (!parsedToolCall) {
+                        if (forcePlanningToolCall) {
+                            const fallbackToolCall = buildFallbackPlanningToolCall(input, effectiveBoundTools, text);
+                            if (fallbackToolCall) {
+                                return fallbackToolCall;
+                            }
+                        }
                         return rawResult;
                     }
                     if (hasPriorToolResultForToolName(input, parsedToolCall.name)) {

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

@@ -48,6 +48,23 @@ function isSubstantiveTerminalAssistantOutput(value) {
     }
     return true;
 }
+function inferPlanItemStatusFromTerminalAssistantOutput(value) {
+    const terminalStatus = readTerminalExecutionStatus(value);
+    if (terminalStatus) {
+        return mapTerminalStatusToPlanItemStatus(terminalStatus);
+    }
+    const normalized = sanitizeVisibleText(value).trim().toLowerCase();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized.startsWith("runtime_error=")
+        || /\bterminated\b/i.test(normalized)
+        || /\b(?:blocked|blocker|failed|failure|refused|unable to complete|could not complete)\b/i.test(normalized)
+        || /(?:执行失败|未能完成|无法完成|阻塞|失败)/u.test(normalized)) {
+        return "failed";
+    }
+    return isSubstantiveTerminalAssistantOutput(value) ? "completed" : null;
+}
 function reconcilePlanStateToTerminalStatus(planState, status, updatedAt) {
     const items = planState.items.map((item) => ({
         ...item,
@@ -1026,8 +1043,9 @@ export async function* streamHarnessRun(options) {
             }
         }
         currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
-        if (isSubstantiveTerminalAssistantOutput(assistantOutput) && planStateHasActiveItems(currentPlanState)) {
-            const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, "completed", new Date().toISOString());
+        const terminalAssistantPlanItemStatus = inferPlanItemStatusFromTerminalAssistantOutput(assistantOutput);
+        if (terminalAssistantPlanItemStatus && planStateHasActiveItems(currentPlanState)) {
+            const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalAssistantPlanItemStatus, new Date().toISOString());
             const signature = buildPlanStateSignature(reconciledPlanState);
             if (signature !== lastPlanStateSignature) {
                 const previousPlanState = currentPlanState;

package/package.json

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