@botbotgo/agent-harness 0.0.378 → 0.0.380

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.378";
+export declare const AGENT_HARNESS_VERSION = "0.0.380";
 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.378";
+export const AGENT_HARNESS_VERSION = "0.0.380";
 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));
@@ -485,11 +511,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 +532,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,8 +543,11 @@ 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;
                     }
@@ -540,6 +578,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 +597,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

@@ -236,7 +236,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;

package/package.json

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