@botbotgo/agent-harness 0.0.309 → 0.0.310

package/dist/runtime/parsing/output-recovery.d.ts

@@ -0,0 +1,14 @@
+export declare function isToolCallValidationFailure(error: unknown): boolean;
+export declare function isWorkspacePathScopeFailure(error: unknown): boolean;
+export declare function isRepairableWriteTodosPlaceholderFailure(error: unknown): boolean;
+export declare function isRepairableWriteTodosContentFailure(error: unknown): boolean;
+export declare function isRepairableWriteTodosEmptyFailure(error: unknown): boolean;
+export declare function isToolCallRecoveryFailure(error: unknown): boolean;
+export declare function isRetrySafeInvalidToolSelectionError(value: unknown): boolean;
+export declare function shouldValidateExecutionWithoutToolEvidence(request: unknown): boolean;
+export declare function resolveExecutionWithoutToolEvidenceInstruction(request: unknown, result: unknown): string | null;
+export declare function resolveExecutionWithoutToolEvidenceTextInstruction(request: unknown, assistantText: string, toolCallEvidence?: boolean): string | null;
+export declare function resolveToolCallRecoveryInstruction(error: unknown): string | null;
+export declare function appendToolRecoveryInstruction(input: unknown, instruction: string): unknown;
+export declare function wrapResolvedModel<T>(value: T): T;
+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 } from "../prompts/runtime-prompts.js";

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

@@ -0,0 +1,288 @@
+import { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_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 "../prompts/runtime-prompts.js";
+import { hasToolCalls, readTextContent, wrapNormalizedMessage } from "./output-content.js";
+function isToolCallParseFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /error parsing tool call:/i.test(error.message);
+}
+function isStructuredValidationIssue(value) {
+    if (typeof value !== "object" || !value || Array.isArray(value)) {
+        return false;
+    }
+    const typed = value;
+    return typeof typed.code === "string" && Array.isArray(typed.path) && (typed.message === undefined || typeof typed.message === "string");
+}
+export function isToolCallValidationFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.trim();
+    if (!message)
+        return false;
+    try {
+        const direct = JSON.parse(message);
+        if (Array.isArray(direct) && direct.length > 0 && direct.every((issue) => isStructuredValidationIssue(issue) && issue.path.length > 0)) {
+            return true;
+        }
+    }
+    catch { }
+    if (/Invalid input:\s*expected .* received undefined/i.test(message) && /"path"\s*:\s*\[/.test(message)) {
+        return true;
+    }
+    return /Received tool input did not match expected schema/i.test(message) && /(?:→\s*at|at)\s+[\w[\].]+/i.test(message);
+}
+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);
+}
+export function isRepairableWriteTodosContentFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.trim();
+    if (!message)
+        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 isToolCallRecoveryFailure(error) {
+    return (isToolCallParseFailure(error) ||
+        isToolCallValidationFailure(error) ||
+        isRepairableWriteTodosEmptyFailure(error) ||
+        isRepairableWriteTodosPlaceholderFailure(error) ||
+        isWorkspacePathScopeFailure(error));
+}
+function extractMessageContent(message) {
+    if (typeof message !== "object" || !message)
+        return "";
+    const typed = message;
+    if (typed.content !== undefined)
+        return readTextContent(typed.content);
+    if (typeof typed.kwargs === "object" && typed.kwargs) {
+        return readTextContent(typed.kwargs.content);
+    }
+    return "";
+}
+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);
+}
+function extractAssistantTextFromResult(result) {
+    if (typeof result === "object" && result && "messages" in result) {
+        const messages = result.messages;
+        if (Array.isArray(messages)) {
+            for (let index = messages.length - 1; index >= 0; index -= 1) {
+                const message = messages[index];
+                if (typeof message !== "object" || !message)
+                    continue;
+                const ids = Array.isArray(message.id)
+                    ? message.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 === "AIMessage" || runtimeType === "ai") {
+                    return extractMessageContent(message).trim();
+                }
+            }
+        }
+    }
+    return "";
+}
+export function resolveExecutionWithoutToolEvidenceInstruction(request, result) {
+    const assistantText = typeof result === "object" && result && "content" in result
+        ? readTextContent(result.content).trim()
+        : extractAssistantTextFromResult(result);
+    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 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;
+    }
+    return null;
+}
+export function appendToolRecoveryInstruction(input, instruction) {
+    if (Array.isArray(input)) {
+        return [...input, { role: "system", content: instruction }];
+    }
+    if (typeof input === "object" && input && Array.isArray(input.messages)) {
+        return {
+            ...input,
+            messages: [...(input.messages), { role: "system", content: instruction }],
+        };
+    }
+    return input;
+}
+export function wrapResolvedModel(value) {
+    if (typeof value !== "object" || value === null)
+        return value;
+    const target = value;
+    return new Proxy(target, {
+        get(currentTarget, prop, receiver) {
+            const member = Reflect.get(currentTarget, prop, receiver);
+            if (prop === "invoke" && typeof member === "function") {
+                return async (...args) => {
+                    let activeArgs = [...args];
+                    for (let attempt = 0; attempt < 3; attempt += 1) {
+                        try {
+                            const normalized = wrapNormalizedMessage(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);
+                        }
+                    }
+                    throw new Error("Model invocation retry loop exited unexpectedly.");
+                };
+            }
+            if ((prop === "bindTools" || prop === "withConfig" || prop === "withStructuredOutput") && typeof member === "function") {
+                return (...args) => wrapResolvedModel(member.apply(currentTarget, args));
+            }
+            if (typeof member === "function")
+                return member.bind(currentTarget);
+            return member;
+        },
+    });
+}
+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 } from "../prompts/runtime-prompts.js";

package/dist/runtime/parsing/output-tool-args.d.ts

@@ -0,0 +1,4 @@
+export declare function tryParseJson(value: string): unknown | null;
+export declare function salvageToolArgs(value: unknown): Record<string, unknown> | null;
+export declare function normalizeKnownToolArgs(toolName: unknown, args: Record<string, unknown>): Record<string, unknown>;
+export declare function isLikelyToolArgsObject(value: unknown): boolean;

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

@@ -0,0 +1,120 @@
+export function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function extractBalancedJsonObject(value) {
+    const start = value.indexOf("{");
+    if (start < 0)
+        return null;
+    let depth = 0;
+    let inString = false;
+    let escaping = false;
+    for (let index = start; index < value.length; index += 1) {
+        const char = value[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaping = true;
+                continue;
+            }
+            if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return value.slice(start, index + 1);
+            }
+        }
+    }
+    return null;
+}
+export function salvageToolArgs(value) {
+    if (typeof value === "object" && value && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return {};
+    }
+    const direct = tryParseJson(trimmed);
+    if (typeof direct === "object" && direct && !Array.isArray(direct)) {
+        return direct;
+    }
+    const embedded = extractBalancedJsonObject(trimmed);
+    if (!embedded) {
+        return null;
+    }
+    const parsed = tryParseJson(embedded);
+    return typeof parsed === "object" && parsed && !Array.isArray(parsed) ? parsed : null;
+}
+function normalizeWriteTodosArgs(args) {
+    if (!Array.isArray(args.todos)) {
+        return args;
+    }
+    return {
+        ...args,
+        todos: args.todos.map((todo) => {
+            if (typeof todo !== "object" || !todo || Array.isArray(todo)) {
+                return todo;
+            }
+            const record = todo;
+            const content = typeof record.content === "string" && record.content.trim().length > 0
+                ? record.content
+                : typeof record.description === "string" && record.description.trim().length > 0
+                    ? record.description
+                    : undefined;
+            const normalized = {};
+            if (content !== undefined)
+                normalized.content = content;
+            if (typeof record.status === "string")
+                normalized.status = record.status;
+            return Object.keys(normalized).length > 0 ? normalized : todo;
+        }),
+    };
+}
+export function normalizeKnownToolArgs(toolName, args) {
+    if (toolName === "write_todos") {
+        return normalizeWriteTodosArgs(args);
+    }
+    return args;
+}
+export function isLikelyToolArgsObject(value) {
+    if (typeof value !== "object" || !value || Array.isArray(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    if (keys.length === 0 || keys.length > 8) {
+        return false;
+    }
+    if (keys.some((key) => ["messages", "output", "content", "todos", "files", "skillsMetadata", "memoryContents"].includes(key))) {
+        return false;
+    }
+    return Object.values(value).every((item) => {
+        if (item == null)
+            return true;
+        if (typeof item === "string" || typeof item === "number" || typeof item === "boolean")
+            return true;
+        return Array.isArray(item) && item.every((entry) => typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean");
+    });
+}

package/dist/runtime/support/runtime-factories.js

@@ -3,7 +3,7 @@ import { MemorySaver } from "@langchain/langgraph";
 import { FileCheckpointSaver } from "../maintenance/file-checkpoint-saver.js";
 import { SqliteCheckpointSaver } from "../maintenance/sqlite-checkpoint-saver.js";
 import { createInMemoryStore, FileBackedStore, SqliteBackedStore } from "../harness/system/store.js";
-import { resolveKnowledgeFileStorePath, resolveKnowledgeStorePath, resolveRuntimeCheckpointerPath, } from "./runtime-layout.js";
+import { resolveKnowledgeFileStorePath, resolveKnowledgeStorePath, resolveRuntimeCheckpointerPath, } from "../layout/runtime-layout.js";
 export function createStoreForConfig(storeConfig, runtimeRoot) {
     const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";
     switch (kind) {

package/dist/scaffold/init-project.d.ts

@@ -0,0 +1,12 @@
+export type InitTemplate = "deep-research" | "single-agent";
+export type InitProjectOptions = {
+    template?: InitTemplate;
+    provider?: string;
+    model?: string;
+    withWebSearch?: boolean;
+};
+export type InitProjectResult = {
+    projectRoot: string;
+    projectSlug: string;
+};
+export declare function initProject(projectRoot: string, projectName: string, options?: InitProjectOptions): Promise<InitProjectResult>;