@botbotgo/agent-harness 0.0.379 → 0.0.381

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.379";
+export declare const AGENT_HARNESS_VERSION = "0.0.381";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.379";
+export const AGENT_HARNESS_VERSION = "0.0.381";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";

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

@@ -212,14 +212,14 @@ function isTodoPlanningToolName(name) {
         || name === "tool_call_write_todos"
         || name === "tool_call_read_todos";
 }
-function shouldLimitPromptedJsonToolsToPlanning(input) {
+function shouldLimitToolsToPlanning(input) {
     const text = stringifyNodeLlamaCppInput(input);
     return text.includes("required visible planning contract")
         && !hasPriorToolResultForToolName(input, "write_todos")
         && !hasPriorToolResultForToolName(input, "tool_call_write_todos");
 }
-function selectPromptedJsonToolsForTurn(input, boundTools) {
-    if (!shouldLimitPromptedJsonToolsToPlanning(input)) {
+function selectPlanningToolsForTurn(input, boundTools) {
+    if (!shouldLimitToolsToPlanning(input)) {
         return boundTools;
     }
     const planningTools = boundTools.filter((tool) => isTodoPlanningToolName(readBoundToolName(tool)));
@@ -270,26 +270,52 @@ function normalizeProviderFacingInput(input) {
     }
     return input;
 }
-function createProviderToolMessageCompatModel(model) {
+function createProviderToolMessageCompatModel(model, boundTools = []) {
+    const resolveTargetForTurn = (input) => {
+        if (boundTools.length === 0 || typeof model.bindTools !== "function") {
+            return model;
+        }
+        const effectiveBoundTools = selectPlanningToolsForTurn(input, boundTools);
+        return model.bindTools.call(model, effectiveBoundTools);
+    };
     return new Proxy(model, {
         has(target, prop) {
-            if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "withConfig") {
+            if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "streamEvents" || prop === "withConfig") {
                 return true;
             }
             return prop in target;
         },
         get(target, prop, receiver) {
             if (prop === "bindTools") {
-                return (tools) => {
-                    const bound = target.bindTools.call(target, tools);
-                    return createProviderToolMessageCompatModel(bound);
-                };
+                return (tools) => createProviderToolMessageCompatModel(target, tools);
             }
             if (prop === "invoke") {
-                return (input, config) => target.invoke.call(target, normalizeProviderFacingInput(input), config);
+                return (input, config) => {
+                    const effectiveTarget = resolveTargetForTurn(input);
+                    return effectiveTarget.invoke.call(effectiveTarget, normalizeProviderFacingInput(input), config);
+                };
             }
             if (prop === "stream") {
-                return (input, config) => target.stream.call(target, normalizeProviderFacingInput(input), config);
+                return (input, config) => {
+                    const effectiveTarget = resolveTargetForTurn(input);
+                    return effectiveTarget.stream.call(effectiveTarget, normalizeProviderFacingInput(input), config);
+                };
+            }
+            if (prop === "streamEvents") {
+                return (input, config) => {
+                    const effectiveTarget = resolveTargetForTurn(input);
+                    if (typeof effectiveTarget.streamEvents === "function") {
+                        return effectiveTarget.streamEvents.call(effectiveTarget, normalizeProviderFacingInput(input), config);
+                    }
+                    return (async function* () {
+                        const output = await effectiveTarget.invoke.call(effectiveTarget, normalizeProviderFacingInput(input), config);
+                        yield {
+                            event: "on_chat_model_end",
+                            name: typeof effectiveTarget.constructor?.name === "string" ? effectiveTarget.constructor.name : "ChatModel",
+                            data: { output },
+                        };
+                    })();
+                };
             }
             if (prop === "withConfig" && typeof target.withConfig === "function") {
                 return (config) => createProviderToolMessageCompatModel(target.withConfig.call(target, config));
@@ -463,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;
@@ -485,11 +570,20 @@ function withPromptedJsonToolPrompt(input, tools, options = {}) {
     if (toolInstructions.length === 0) {
         return stringifyNodeLlamaCppInput(input);
     }
+    const forcedPlanningInstruction = options.forcePlanningToolCall
+        ? [
+            "Required planning tool call:",
+            "You must call write_todos now before any domain tool or final answer.",
+            "Return exactly one JSON object for write_todos with concrete todo items and statuses.",
+            "Do not write prose, markdown, analysis, or a plain-text plan.",
+        ].join("\n")
+        : "";
     const systemContent = `${NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION}\n\n${toolInstructions.join("\n\n")}`;
     const prompt = stringifyNodeLlamaCppInput(input);
     return [
         options.suppressThinking ? NO_THINK_CONTROL_TOKEN : "",
         systemContent,
+        forcedPlanningInstruction,
         prompt,
         PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER,
     ].filter(Boolean).join("\n\n");
@@ -497,7 +591,7 @@ function withPromptedJsonToolPrompt(input, tools, options = {}) {
 function createPromptedJsonToolBindableModel(model, boundTools = [], options = {}) {
     return new Proxy(model, {
         has(target, prop) {
-            if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "withConfig") {
+            if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "streamEvents" || prop === "withConfig") {
                 return true;
             }
             return prop in target;
@@ -508,14 +602,23 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
             }
             if (prop === "invoke") {
                 return async (input, config) => {
-                    const effectiveBoundTools = selectPromptedJsonToolsForTurn(input, boundTools);
-                    const rawResult = await target.invoke(effectiveBoundTools.length > 0 ? withPromptedJsonToolPrompt(input, effectiveBoundTools, options) : input, config);
+                    const effectiveBoundTools = selectPlanningToolsForTurn(input, boundTools);
+                    const forcePlanningToolCall = shouldLimitToolsToPlanning(input);
+                    const rawResult = await target.invoke(effectiveBoundTools.length > 0
+                        ? withPromptedJsonToolPrompt(input, effectiveBoundTools, { ...options, forcePlanningToolCall })
+                        : input, config);
                     if (effectiveBoundTools.length === 0) {
                         return rawResult;
                     }
                     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)) {
@@ -540,6 +643,18 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                     })();
                 };
             }
+            if (prop === "streamEvents") {
+                return async (input, config) => {
+                    const value = await receiver.invoke(input, config);
+                    return (async function* () {
+                        yield {
+                            event: "on_chat_model_end",
+                            name: typeof target.constructor?.name === "string" ? target.constructor.name : "ChatModel",
+                            data: { output: value },
+                        };
+                    })();
+                };
+            }
             if (prop === "withConfig" && typeof target.withConfig === "function") {
                 return (config) => createPromptedJsonToolBindableModel(target.withConfig(config), boundTools, options);
             }
@@ -547,7 +662,7 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
             return typeof member === "function" ? member.bind(target) : member;
         },
         getOwnPropertyDescriptor(target, prop) {
-            if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "withConfig") {
+            if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "streamEvents" || prop === "withConfig") {
                 return {
                     configurable: true,
                     enumerable: false,

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,
@@ -236,7 +253,10 @@ function getPlanStateFromUpstreamEvent(input) {
         return null;
     }
     const typed = input.event;
-    const todos = extractTodosArray(typed.data?.output)
+    const isWriteTodosStart = typed.event === "on_tool_start"
+        && typed.name === "write_todos";
+    const todos = (isWriteTodosStart ? extractTodosArray(typed.data?.input) : null)
+        ?? extractTodosArray(typed.data?.output)
         ?? extractTodosArray(typed.data?.chunk);
     if (!todos) {
         return null;
@@ -1023,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.379",
+  "version": "0.0.381",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",