@botbotgo/agent-harness 0.0.298 → 0.0.300

package/dist/runtime/parsing/output-parsing.js

@@ -1,4 +1,6 @@
 import { AIMessage } from "langchain";
+import { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, } from "../support/runtime-prompts.js";
+export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, };
 export function sanitizeVisibleText(value) {
     return value
         .replace(/[A-Za-z0-9_]*Middleware\.after_model/g, "")
@@ -218,6 +220,13 @@ function extractAssistantTextFromMessages(messages) {
         if (typeof message !== "object" || !message)
             continue;
         const typed = message;
+        const explicitRole = typeof typed.role === "string" ? typed.role.trim().toLowerCase() : undefined;
+        if (explicitRole === "assistant" || explicitRole === "ai") {
+            const content = extractMessageContent(message);
+            if (content)
+                return content;
+            continue;
+        }
         const ids = Array.isArray(typed.id) ? typed.id.filter((item) => typeof item === "string") : [];
         const typeName = ids.at(-1);
         const runtimeType = typeof message._getType === "function"
@@ -295,11 +304,54 @@ function extractStructuredOutputText(value) {
     }
     return readTextContent(typed.content);
 }
+function normalizePotentialLineNumberedDocument(value) {
+    return value
+        .split("\n")
+        .map((line) => line.replace(/^\s*\d+\s+/, ""))
+        .join("\n")
+        .trim();
+}
+function isLikelySkillDocumentText(value) {
+    const normalized = normalizePotentialLineNumberedDocument(value);
+    if (!normalized.startsWith("---")) {
+        return false;
+    }
+    const lower = normalized.toLowerCase();
+    return (lower.includes("\nname: ") &&
+        lower.includes("\ndescription: ") &&
+        lower.includes("\n# ") &&
+        lower.includes("## workflow"));
+}
+export function containsLikelySkillDocument(value) {
+    if (typeof value === "string") {
+        return isLikelySkillDocumentText(value);
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => containsLikelySkillDocument(item));
+    }
+    if (typeof value === "object" && value) {
+        const typed = value;
+        if (typed.content !== undefined && containsLikelySkillDocument(typed.content)) {
+            return true;
+        }
+        if (typed.output !== undefined && containsLikelySkillDocument(typed.output)) {
+            return true;
+        }
+        if (typed.messages !== undefined && containsLikelySkillDocument(typed.messages)) {
+            return true;
+        }
+        if (typed.kwargs !== undefined && containsLikelySkillDocument(typed.kwargs)) {
+            return true;
+        }
+        return Object.values(typed).some((item) => containsLikelySkillDocument(item));
+    }
+    return false;
+}
 export function extractToolFallbackContext(value) {
     if (typeof value !== "object" || !value)
         return "";
     const typed = value;
-    const messages = extractToolMessageContents(typed.messages);
+    const messages = extractToolMessageContents(typed.messages).filter((message) => !isLikelySkillDocumentText(message));
     if (messages.length > 0)
         return messages.slice(-3).join("\n\n");
     if (typed.output && typeof typed.output === "object") {
@@ -311,7 +363,7 @@ export function extractToolFallbackContext(value) {
 }
 export function extractVisibleOutput(value) {
     const structured = extractStructuredOutputText(value);
-    if (structured)
+    if (structured && !isLikelySkillDocumentText(structured))
         return structured;
     if (typeof value === "string") {
         const parsed = tryParseJson(value);
@@ -319,11 +371,13 @@ export function extractVisibleOutput(value) {
             if (isLikelyMemoryWriteArgsObject(parsed))
                 return "";
             const parsedStructured = extractStructuredOutputText(parsed);
-            if (parsedStructured)
+            if (parsedStructured && !isLikelySkillDocumentText(parsedStructured))
                 return parsedStructured;
             if (isLikelyToolArgsObject(parsed))
                 return "";
         }
+        if (isLikelySkillDocumentText(value))
+            return "";
         return value;
     }
     if (typeof value === "object" && value) {
@@ -515,10 +569,128 @@ export function isToolCallValidationFailure(error) {
     return /Received tool input did not match expected schema/i.test(message) && /(?:→\s*at|at)\s+[\w[\].]+/i.test(message);
 }
 export function isToolCallRecoveryFailure(error) {
-    return isToolCallParseFailure(error) || isToolCallValidationFailure(error);
+    return (isToolCallParseFailure(error) ||
+        isToolCallValidationFailure(error) ||
+        isRepairableWriteTodosEmptyFailure(error) ||
+        isRepairableWriteTodosPlaceholderFailure(error) ||
+        isWorkspacePathScopeFailure(error));
+}
+function collectErrorMessages(error) {
+    if (!error) {
+        return [];
+    }
+    if (error instanceof Error) {
+        const nested = Array.isArray(error.errors)
+            ? (error.errors ?? []).flatMap((item) => collectErrorMessages(item))
+            : [];
+        return [error.message, ...nested].filter((value) => typeof value === "string" && value.trim().length > 0);
+    }
+    if (typeof error === "string" && error.trim().length > 0) {
+        return [error];
+    }
+    if (typeof error === "object") {
+        const record = error;
+        return [record.message, record.error, record.details].flatMap((item) => collectErrorMessages(item));
+    }
+    return [];
+}
+export function isWorkspacePathScopeFailure(error) {
+    return collectErrorMessages(error).some((message) => /outside the workspace root|workspace-relative path/i.test(message));
+}
+export function isRepairableWriteTodosPlaceholderFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.trim();
+    if (!message)
+        return false;
+    return /write_todos/i.test(message) && /descriptive task content|placeholder entries/i.test(message);
+}
+function extractLastUserMessageText(input) {
+    if (!Array.isArray(input) && !(typeof input === "object" && input && Array.isArray(input.messages))) {
+        return "";
+    }
+    const messages = Array.isArray(input) ? input : input.messages;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (typeof message !== "object" || !message)
+            continue;
+        const typed = message;
+        if (typed.role === "user") {
+            return extractMessageContent(message).trim();
+        }
+        const ids = Array.isArray(typed.id) ? typed.id.filter((item) => typeof item === "string") : [];
+        const typeName = ids.at(-1);
+        const runtimeType = typeof message._getType === "function"
+            ? message._getType()
+            : typeof message.getType === "function"
+                ? message.getType()
+                : undefined;
+        if (typeName === "HumanMessage" || runtimeType === "human") {
+            return extractMessageContent(message).trim();
+        }
+        if (typeof typed.kwargs === "object" && typed.kwargs && typed.kwargs.role === "user") {
+            return extractMessageContent(message).trim();
+        }
+    }
+    return "";
+}
+function isToolRequiredExecutionPrompt(text) {
+    if (!text)
+        return false;
+    return (/write_todos/i.test(text) ||
+        /\b(create|write|edit|read|show|display|append|run|execute|wait|sleep|repeat|loop|file|files|command)\b/i.test(text) ||
+        /(创建|写入|读取|显示|追加|执行|运行|等待|重复|文件|命令|步骤)/.test(text));
+}
+function isBrowserOrUrlTask(text) {
+    if (!text)
+        return false;
+    return (/https?:\/\/\S+/i.test(text) ||
+        /\b(url|urls|website|websites|web page|webpage|browser|browse|page summary|summari[sz]e.*page|open.*page)\b/i.test(text) ||
+        /(网址|链接|网页|网站|页面|浏览器|总结.*网页|总结.*页面|打开.*网页)/.test(text));
+}
+function claimsExecutionWithoutToolEvidence(text) {
+    if (!text)
+        return false;
+    return (/\b(completed|done|created|wrote|written|read|displayed|appended|executed|waited|result|results)\b/i.test(text) ||
+        /(已创建|已写入|已读取|已显示|已追加|已执行|已等待|执行结果|状态更新|步骤\s*\d+|文件内容)/.test(text));
+}
+function claimsMissingBrowserCapability(text) {
+    if (!text)
+        return false;
+    return (/\b(i do not have the capability to access external websites|i do not have access to external websites|i cannot access external websites|i can(?:not|'t) browse|i do not have (?:direct )?(?:web|browser|browsing) access|i do not have .*tool.*(?:website|url|browser)|i cannot summarize .* because .*tool.*failed|please provide (?:the )?text content.*i (?:will|can) summarize)\b/i.test(text) ||
+        /(我没有直接访问外部网站|我无法直接访问外部网站|我无法访问外部网站|我不能访问外部网站|我无法直接访问外部网站内容|我无法访问网页|请提供文本内容.*我将为您进行总结|我没有.*浏览.*工具|我没有.*网页抓取.*工具|我没有.*访问.*网站.*工具|我无法总结该网页内容，因为.*工具执行失败)/.test(text));
+}
+export function isRetrySafeInvalidToolSelectionError(value) {
+    const text = readTextContent(value).trim();
+    if (!text)
+        return false;
+    return /is not a valid tool, try one of \[/i.test(text);
+}
+export function shouldValidateExecutionWithoutToolEvidence(request) {
+    const userText = extractLastUserMessageText(request);
+    const browserOrUrlTask = isBrowserOrUrlTask(userText);
+    return browserOrUrlTask || isToolRequiredExecutionPrompt(userText);
+}
+export function resolveExecutionWithoutToolEvidenceInstruction(request, result) {
+    const assistantText = AIMessage.isInstance(result)
+        ? readTextContent(result.content).trim()
+        : extractAssistantTextFromMessages(result?.messages).trim();
+    return resolveExecutionWithoutToolEvidenceTextInstruction(request, assistantText, hasToolCalls(result));
+}
+export function resolveExecutionWithoutToolEvidenceTextInstruction(request, assistantText, toolCallEvidence = false) {
+    const userText = extractLastUserMessageText(request);
+    const browserOrUrlTask = isBrowserOrUrlTask(userText);
+    if (!shouldValidateExecutionWithoutToolEvidence(request)) {
+        return null;
+    }
+    if (!assistantText || toolCallEvidence) {
+        return null;
+    }
+    if (browserOrUrlTask && claimsMissingBrowserCapability(assistantText)) {
+        return BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION;
+    }
+    return claimsExecutionWithoutToolEvidence(assistantText) ? EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION : null;
 }
-export const STRICT_TOOL_JSON_INSTRUCTION = "When calling tools, return only the tool call itself. The arguments must be a pure JSON object with no explanatory text before or after it.";
-export const WRITE_TODOS_FULL_ENTRY_INSTRUCTION = "When calling write_todos, every todo item must include both content and status. Do not send status-only updates. Retry by resending the full todo entry with the original content preserved.";
 export function isRepairableWriteTodosContentFailure(error) {
     if (!(error instanceof Error))
         return false;
@@ -527,10 +699,27 @@ export function isRepairableWriteTodosContentFailure(error) {
         return false;
     return /write_todos/i.test(message) && /todos\[\d+\]\.content/i.test(message);
 }
+export function isRepairableWriteTodosEmptyFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.trim();
+    if (!message)
+        return false;
+    return /write_todos/i.test(message) && /Initial write_todos call cannot use an empty todo list/i.test(message);
+}
 export function resolveToolCallRecoveryInstruction(error) {
+    if (isRepairableWriteTodosEmptyFailure(error)) {
+        return WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION;
+    }
     if (isRepairableWriteTodosContentFailure(error)) {
         return WRITE_TODOS_FULL_ENTRY_INSTRUCTION;
     }
+    if (isRepairableWriteTodosPlaceholderFailure(error)) {
+        return WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION;
+    }
+    if (isWorkspacePathScopeFailure(error)) {
+        return WORKSPACE_RELATIVE_PATH_INSTRUCTION;
+    }
     if (isToolCallRecoveryFailure(error)) {
         return STRICT_TOOL_JSON_INSTRUCTION;
     }
@@ -557,18 +746,36 @@ export function wrapResolvedModel(value) {
             const member = Reflect.get(currentTarget, prop, receiver);
             if (prop === "invoke" && typeof member === "function") {
                 return async (...args) => {
-                    try {
-                        return normalizeAgentMessage(await member.apply(currentTarget, args));
-                    }
-                    catch (error) {
-                        const recoveryInstruction = resolveToolCallRecoveryInstruction(error);
-                        if (!recoveryInstruction) {
-                            throw error;
+                    let activeArgs = [...args];
+                    for (let attempt = 0; attempt < 3; attempt += 1) {
+                        try {
+                            const normalized = normalizeAgentMessage(await member.apply(currentTarget, activeArgs));
+                            const executionRecoveryInstruction = resolveExecutionWithoutToolEvidenceInstruction(activeArgs[0], normalized);
+                            if (!executionRecoveryInstruction) {
+                                return normalized;
+                            }
+                            if (attempt === 2) {
+                                throw new Error("Model claimed task execution without any tool calls after repeated recovery attempts. Refusing to treat that response as a successful execution.");
+                            }
+                            const nextInstruction = attempt === 0
+                                ? executionRecoveryInstruction
+                                : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;
+                            activeArgs = [...activeArgs];
+                            activeArgs[0] = appendToolRecoveryInstruction(activeArgs[0], nextInstruction);
+                        }
+                        catch (error) {
+                            const recoveryInstruction = resolveToolCallRecoveryInstruction(error);
+                            if (!recoveryInstruction) {
+                                throw error;
+                            }
+                            if (attempt === 2) {
+                                throw error;
+                            }
+                            activeArgs = [...activeArgs];
+                            activeArgs[0] = appendToolRecoveryInstruction(activeArgs[0], recoveryInstruction);
                         }
-                        const retryArgs = [...args];
-                        retryArgs[0] = appendToolRecoveryInstruction(retryArgs[0], recoveryInstruction);
-                        return normalizeAgentMessage(await member.apply(currentTarget, retryArgs));
                     }
+                    throw new Error("Model invocation retry loop exited unexpectedly.");
                 };
             }
             if ((prop === "bindTools" || prop === "withConfig" || prop === "withStructuredOutput") && typeof member === "function") {

package/dist/runtime/parsing/stream-event-parsing.d.ts

@@ -1,6 +1,10 @@
+import type { RequestExecutionStep } from "../../contracts/types.js";
 export type RuntimeStreamChunk = {
     kind: "upstream-event";
     event: unknown;
+} | {
+    kind: "commentary";
+    content: string;
 } | {
     kind: "content";
     content: string;
@@ -15,6 +19,9 @@ export type RuntimeStreamChunk = {
     toolName: string;
     output: unknown;
     isError?: boolean;
+} | {
+    kind: "profile";
+    step: RequestExecutionStep;
 };
 export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;

package/dist/runtime/parsing/stream-event-parsing.js

@@ -1,3 +1,4 @@
+import { isLowSignalTodoContent } from "../adapter/runtime-adapter-support.js";
 import { extractReasoningText, extractVisibleOutput, hasToolCalls, readTextContent } from "./output-parsing.js";
 function parseMaybeJson(value) {
     const trimmed = value.trim();
@@ -11,6 +12,22 @@ function parseMaybeJson(value) {
         return value;
     }
 }
+function unwrapToolMessageOutput(value) {
+    if (typeof value !== "object" || !value || Array.isArray(value)) {
+        return value;
+    }
+    const record = value;
+    if (typeof record.content === "string") {
+        return parseMaybeJson(record.content);
+    }
+    const kwargs = typeof record.kwargs === "object" && record.kwargs !== null
+        ? record.kwargs
+        : undefined;
+    if (typeof kwargs?.content === "string") {
+        return parseMaybeJson(kwargs.content);
+    }
+    return value;
+}
 function readToolErrorText(value) {
     if (typeof value === "string") {
         return value;
@@ -36,6 +53,31 @@ function isErrorLikeToolOutput(value) {
     }
     return /(^|\b)(error|exception|failed|failure|denied|timed out|timeout|not permitted|eperm|eacces)(\b|:)/i.test(message);
 }
+function isEmptyInitialWriteTodosResult(value) {
+    if (typeof value !== "object" || !value || Array.isArray(value)) {
+        return false;
+    }
+    const typed = value;
+    if (typeof typed.summary === "object" && typed.summary && Array.isArray(typed.summary.items)) {
+        return (typed.summary.items).length === 0;
+    }
+    if (typeof typed.update === "object" && typed.update && Array.isArray(typed.update.todos)) {
+        return (typed.update.todos).length === 0;
+    }
+    return false;
+}
+function hasLowSignalInitialWriteTodos(value) {
+    if (typeof value !== "object" || !value || Array.isArray(value)) {
+        return false;
+    }
+    const typed = value;
+    const items = typeof typed.summary === "object" && typed.summary && Array.isArray(typed.summary.items)
+        ? (typed.summary.items ?? [])
+        : typeof typed.update === "object" && typed.update && Array.isArray(typed.update.todos)
+            ? (typed.update.todos ?? [])
+            : [];
+    return items.length > 0 && items.every((item) => typeof item?.content === "string" && isLowSignalTodoContent(item.content));
+}
 export function extractTerminalStreamOutput(event) {
     if (typeof event !== "object" || !event)
         return "";
@@ -93,7 +135,15 @@ export function extractToolResult(event) {
         return null;
     }
     const rawOutput = isToolError ? typed.data?.error ?? typed.data?.output : typed.data?.output;
-    const normalizedOutput = typeof rawOutput === "string" ? parseMaybeJson(rawOutput) : rawOutput;
+    const normalizedOutput = typeof rawOutput === "string"
+        ? parseMaybeJson(rawOutput)
+        : unwrapToolMessageOutput(rawOutput);
+    if (!isToolError && toolName === "write_todos" && isEmptyInitialWriteTodosResult(normalizedOutput)) {
+        throw new Error("Error invoking tool 'write_todos' with kwargs {\"todos\":[]} with error: Error: Initial write_todos call cannot use an empty todo list. Send the concrete task steps with both content and status.");
+    }
+    if (!isToolError && toolName === "write_todos" && hasLowSignalInitialWriteTodos(normalizedOutput)) {
+        throw new Error("Error invoking tool 'write_todos' with placeholder todo content with error: Error: Initial write_todos call must use descriptive task content. Do not use placeholder entries like '1', '2', or 'step 1'.");
+    }
     return {
         toolName,
         output: normalizedOutput,

package/dist/runtime/scheduling/system-schedule-manager.d.ts

@@ -0,0 +1,41 @@
+import type { RuntimeScheduleManageInput, RuntimeScheduleManageResult, RuntimeScheduleManager, RuntimeScheduleRecord } from "../../contracts/types.js";
+type CommandResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};
+type CommandRunner = (command: string, args: string[], options?: {
+    input?: string;
+}) => Promise<CommandResult>;
+type SystemScheduleManagerOptions = {
+    workspaceRoot: string;
+    runtimeRoot: string;
+    platform?: NodeJS.Platform;
+    nodePath?: string;
+    cliPath?: string;
+    runCommand?: CommandRunner;
+};
+export declare class SystemScheduleManager implements RuntimeScheduleManager {
+    private readonly options;
+    private readonly schedulesRoot;
+    private readonly platform;
+    private readonly nodePath;
+    private readonly cliPath;
+    private readonly adapter;
+    constructor(options: SystemScheduleManagerOptions);
+    private manifestPath;
+    private ensureSchedulesRoot;
+    private writeManifest;
+    private toPublicRecord;
+    private loadStoredRecord;
+    private resolveStatus;
+    getSchedule(scheduleId: string): Promise<RuntimeScheduleRecord | null>;
+    private listStoredRecords;
+    private createSchedule;
+    private listSchedules;
+    private updateSchedule;
+    private deleteSchedule;
+    manageSchedule(input: RuntimeScheduleManageInput): Promise<RuntimeScheduleManageResult>;
+    describeSchedule(record: RuntimeScheduleRecord): string;
+}
+export {};