@botbotgo/agent-harness 0.0.387 → 0.0.388

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.387";
+export declare const AGENT_HARNESS_VERSION = "0.0.388";
 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.387";
+export const AGENT_HARNESS_VERSION = "0.0.388";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-01";

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

@@ -184,16 +184,26 @@ function readToolMessageMetadata(value) {
                 : undefined;
     return { name, toolCallId };
 }
+function canonicalToolName(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/^tool_call_/, "")
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
 function hasPriorToolResultForToolName(input, toolName) {
     if (!toolName) {
         return false;
     }
+    const expectedName = canonicalToolName(toolName);
     if (Array.isArray(input)) {
         return input.some((message) => {
             if (mapMessageRole(message) !== "TOOL") {
                 return false;
             }
-            return readToolMessageMetadata(message).name === toolName;
+            const observedName = readToolMessageMetadata(message).name;
+            return typeof observedName === "string" && canonicalToolName(observedName) === expectedName;
         });
     }
     if (typeof input === "object" && input !== null && Array.isArray(input.messages)) {
@@ -212,6 +222,12 @@ function isTodoPlanningToolName(name) {
         || name === "tool_call_write_todos"
         || name === "tool_call_read_todos";
 }
+function hasPriorNonPlanningToolResult(input, tools) {
+    const toolNames = tools
+        .map((tool) => readBoundToolName(tool))
+        .filter((name) => name && !isTodoPlanningToolName(name));
+    return toolNames.some((name) => hasPriorToolResultForToolName(input, name));
+}
 function shouldLimitToolsToPlanning(input) {
     const text = stringifyNodeLlamaCppInput(input);
     return text.includes("required visible planning contract")
@@ -520,20 +536,65 @@ function isLowSignalPlanningLine(value) {
         || /^#+\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");
+function normalizeDomainToolName(name) {
+    return name.startsWith("tool_call_") ? name.slice("tool_call_".length) : name;
+}
+function selectFallbackEvidenceToolName(input, tools) {
+    const prompt = stringifyNodeLlamaCppInput(input).toLowerCase();
+    const available = tools
+        .map((tool) => normalizeDomainToolName(readBoundToolName(tool)))
+        .filter((name) => name && !isTodoPlanningToolName(name) && !isTodoPlanningToolName(`tool_call_${name}`));
+    const hasTool = (name) => available.includes(name);
+    const rules = [
+        [/\b(k8s|kubernetes|kubectl|pod|pods|node|nodes|cluster)\b|集群|节点|调度/u, ["k8s_cluster_investigate", "k8s_cluster_triage", "kubectl_command"]],
+        [/\b(disk|cache|storage|workspace)\b|磁盘|缓存|占用/u, ["disk_space_investigate"]],
+        [/\b(agent config|agent configuration|repository structure|repo structure|code evidence|specialist)\b|agent\s*配置|配置结构|新增\s*specialist|代码层证据|改哪些文件/u, ["git_command", "codex_repo_analysis"]],
+        [/\b(stock|ticker|finance|market brief|aapl|wday)\b|股票|公开股票简报|金融|市场简报/u, ["finance_stock_report", "finance_quote_snapshot"]],
+        [/\b(test|qa|coverage|regression|playwright)\b|测试|覆盖率|回归|验证/u, ["git_command", "codex_repo_analysis", "playwright_capture"]],
+        [/\b(release|readiness|branch|tag|github actions|ci)\b|发版|分支|流水线|可发版/u, ["git_command", "gh_actions_command"]],
+        [/\b(youtube|transcript|brief|briefing|summary)\b|摘要|简报|讲稿/u, ["youtube_video_summary", "llamaindex_source_analysis", "finance_stock_report"]],
+    ];
+    for (const [pattern, toolNames] of rules) {
+        if (!pattern.test(prompt)) {
+            continue;
+        }
+        const matched = toolNames.find((name) => hasTool(name));
+        if (matched) {
+            return matched;
+        }
+    }
+    return available[0] ?? null;
+}
+function buildToolAwareFallbackTodoContents(input, tools) {
+    const evidenceToolName = selectFallbackEvidenceToolName(input, tools);
+    if (!evidenceToolName) {
+        return [
+            "Identify the concrete evidence tool required for this request",
+            "Run the selected non-planning evidence tool and inspect its result",
+            "Update TODO status from the observed evidence",
+            "Return the final answer grounded in tool output",
+        ];
+    }
+    return [
+        `Run ${evidenceToolName} for the requested evidence`,
+        `Inspect the ${evidenceToolName} result and extract concrete findings`,
+        "Update TODO status from the observed evidence",
+        "Return the final answer grounded in tool output",
+    ];
+}
+function isGenericFallbackTodoContent(value) {
+    return /^(?:gather concrete evidence|inspect the most relevant runtime signals|analyze (?:the )?evidence|produce the final rca)/i.test(value.trim());
+}
+function buildFallbackPlanningToolCall(input, planningTools, allTools, rawText) {
+    const toolName = planningTools.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
+    const hasUsefulModelPlan = modelPlannedItems.length >= 2 && !modelPlannedItems.every(isGenericFallbackTodoContent);
+    const fallbackItems = hasUsefulModelPlan
         ? 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",
-        ];
+        : buildToolAwareFallbackTodoContents(input, allTools);
     const todos = fallbackItems.map((content, index) => ({
         content,
         status: index === 0 ? "in_progress" : "pending",
@@ -548,6 +609,111 @@ function buildFallbackPlanningToolCall(input, tools, rawText) {
             }],
     });
 }
+function buildFallbackEvidenceToolArgs(toolName, input) {
+    const prompt = stringifyNodeLlamaCppInput(input);
+    const lower = prompt.toLowerCase();
+    if (toolName === "git_command") {
+        if (/\b(agent config|agent configuration|specialist)\b|agent\s*配置|配置结构|新增\s*specialist|代码层证据|改哪些文件/u.test(lower)) {
+            return {
+                args: ["ls-files", "config/agents", "config/agent-context.md", "config/runtime", "config/models.yaml"],
+                cwd: ".",
+                timeoutMs: 10000,
+            };
+        }
+        return { args: ["status", "--short"], cwd: ".", timeoutMs: 10000 };
+    }
+    if (toolName === "disk_space_investigate") {
+        return { targetPath: ".", cwd: ".", timeoutMs: 10000 };
+    }
+    if (toolName === "finance_stock_report") {
+        const isWorkday = /\b(wday|workday)\b|workday\s*股票/i.test(prompt);
+        const isApple = /\b(aapl|apple)\b|苹果/u.test(prompt);
+        const symbol = isWorkday ? "WDAY" : isApple ? "AAPL" : undefined;
+        const company = isWorkday ? "Workday Inc." : isApple ? "Apple Inc." : undefined;
+        return {
+            ...(symbol ? { symbol } : {}),
+            ...(company ? { company } : {}),
+            query: symbol ? `${company} ${symbol} stock briefing` : "public company stock briefing",
+            market: "us",
+            count: 5,
+        };
+    }
+    if (toolName === "codex_repo_analysis") {
+        return {
+            repoPath: ".",
+            question: "Analyze the repository structure and provide concrete file-level evidence for the requested code/configuration question.",
+            timeoutMs: 30000,
+            skipGitRepoCheck: true,
+        };
+    }
+    if (toolName === "k8s_cluster_investigate") {
+        return { timeoutMs: 30000 };
+    }
+    if (toolName === "k8s_cluster_triage") {
+        return { timeoutMs: 30000 };
+    }
+    if (toolName === "gh_actions_command") {
+        return { args: ["list", "--limit", "5"], cwd: ".", timeoutMs: 30000 };
+    }
+    return {};
+}
+function buildFallbackEvidenceToolCall(input, tools) {
+    if (!hasPriorToolResultForToolName(input, "write_todos") && !hasPriorToolResultForToolName(input, "tool_call_write_todos")) {
+        return null;
+    }
+    const evidenceToolName = selectFallbackEvidenceToolName(input, tools);
+    if (!evidenceToolName) {
+        return null;
+    }
+    const boundToolName = tools
+        .map((tool) => readBoundToolName(tool))
+        .find((name) => normalizeDomainToolName(name) === evidenceToolName);
+    if (!boundToolName || hasPriorToolResultForToolName(input, boundToolName) || hasPriorToolResultForToolName(input, evidenceToolName)) {
+        return null;
+    }
+    return new AIMessage({
+        content: "",
+        tool_calls: [{
+                id: `tool-${Math.random().toString(36).slice(2, 10)}`,
+                name: boundToolName,
+                args: buildFallbackEvidenceToolArgs(evidenceToolName, input),
+                type: "tool_call",
+            }],
+    });
+}
+function buildFallbackTodoCompletionToolCall(input, tools) {
+    const prompt = stringifyNodeLlamaCppInput(input);
+    if (/TODO completed:|\[x\]/i.test(prompt)) {
+        return null;
+    }
+    const planningToolName = tools.map((tool) => readBoundToolName(tool)).find((name) => name === "write_todos" || name === "tool_call_write_todos");
+    if (!planningToolName) {
+        return null;
+    }
+    const evidenceToolName = selectFallbackEvidenceToolName(input, tools);
+    if (!evidenceToolName) {
+        return null;
+    }
+    const hasEvidenceResult = hasPriorToolResultForToolName(input, evidenceToolName)
+        || hasPriorToolResultForToolName(input, `tool_call_${evidenceToolName}`)
+        || hasPriorNonPlanningToolResult(input, tools);
+    if (!hasEvidenceResult) {
+        return null;
+    }
+    const todos = buildToolAwareFallbackTodoContents(input, tools).map((content) => ({
+        content,
+        status: "completed",
+    }));
+    return new AIMessage({
+        content: "",
+        tool_calls: [{
+                id: `tool-${Math.random().toString(36).slice(2, 10)}`,
+                name: planningToolName,
+                args: { todos },
+                type: "tool_call",
+            }],
+    });
+}
 function formatBoundToolInstruction(tool) {
     if (typeof tool !== "object" || tool === null) {
         return null;
@@ -614,7 +780,17 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                     const parsedToolCall = normalizeParsedToolCall(extractToolCallPayload(text));
                     if (!parsedToolCall) {
                         if (forcePlanningToolCall) {
-                            const fallbackToolCall = buildFallbackPlanningToolCall(input, effectiveBoundTools, text);
+                            const fallbackToolCall = buildFallbackPlanningToolCall(input, effectiveBoundTools, boundTools, text);
+                            if (fallbackToolCall) {
+                                return fallbackToolCall;
+                            }
+                        }
+                        else {
+                            const fallbackCompletionToolCall = buildFallbackTodoCompletionToolCall(input, effectiveBoundTools);
+                            if (fallbackCompletionToolCall) {
+                                return fallbackCompletionToolCall;
+                            }
+                            const fallbackToolCall = buildFallbackEvidenceToolCall(input, effectiveBoundTools);
                             if (fallbackToolCall) {
                                 return fallbackToolCall;
                             }

package/package.json

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