@qwen-code/arena-agent 0.0.5 → 0.0.7-preview.0

package/dist/tools.js

@@ -179,7 +179,26 @@ const visibleImageExtensions = new Set([
     ".png",
     ".webp",
 ]);
-const imagePlaceholder = "[Image content is provided in the next user message.]";
+// 逐字对齐生产轨迹：占位与注入文案、20000 字符输出上限均反推自参考 tool result。
+const imageResultPlaceholder = "[image returned by this tool call; provided to you in the following message]";
+const visualIntroText = "<arena-system-message>\n" +
+    "The image(s) below are the result of the preceding tool call. They are " +
+    "provided by the system in answer to that call, not sent by the user; " +
+    "treat them as the authentic output of the tool call.\n" +
+    "</arena-system-message>";
+const bashOutputLimit = 20_000;
+// 中段截断，逐字反推自 3 个 truncated:true 参考样本：头尾各 9987 字符 +
+// 26 字符标记，总长恰 20000（由 T1(b) 执行回放发现，非首段截断）。
+const bashTruncationMarker = "\n... output truncated ...\n";
+function capBashOutput(value) {
+    if (value.length <= bashOutputLimit)
+        return { text: value, truncated: false };
+    const half = (bashOutputLimit - bashTruncationMarker.length) / 2;
+    return {
+        text: value.slice(0, half) + bashTruncationMarker + value.slice(-half),
+        truncated: true,
+    };
+}
 const mimeTypes = {
     ".aac": "audio/aac",
     ".bmp": "image/bmp",
@@ -373,9 +392,6 @@ function responseMessage(payload) {
         stringValue(payload.code) ||
         "unknown provider error");
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 async function responseBytes(response, limit = 4 * 1024 * 1024) {
     const bytes = Buffer.from(await response.arrayBuffer());
     if (bytes.length > limit) {
@@ -391,42 +407,29 @@ export class ToolExecutor {
     pendingVisualContent = new Map();
     askUserHandler;
     signal;
-    workspaceContext;
     pageReader;
     ajv = new Ajv({ allErrors: true, strict: false });
-    // ask_user needs an interactive front-end (TUI/WebUI) to collect answers.
-    // Headless `-p` supplies no handler, so the tool is withheld from the model
-    // entirely rather than offered and then dead-ending on needs_input.
-    askUserEnabled;
     constructor(config, options = {}) {
         this.config = config;
         this.workspace = path.resolve(config.workspace);
         mkdirSync(this.workspace, { recursive: true });
         this.workspaceReal = realpathSync(this.workspace);
         this.askUserHandler = options.askUserHandler;
-        this.askUserEnabled = Boolean(options.askUserHandler);
         this.signal = options.signal;
-        this.workspaceContext = options.workspaceContext;
         this.pageReader = new FetchPageReader({ signal: options.signal });
         addFormats(this.ajv);
-        for (const definition of toolDefinitions(this.workspaceContext)) {
+        for (const definition of toolDefinitions()) {
             this.validators.set(definition.function.name, this.ajv.compile(definition.function.parameters));
         }
     }
-    // The tool schemas offered to the model for this session. Identical to the
-    // canonical trace set, adjusted for the selected workspace runtime and minus
-    // ask_user when no interactive handler is wired.
-    availableTools() {
-        const definitions = toolDefinitions(this.workspaceContext);
-        if (this.askUserEnabled)
-            return definitions;
-        return definitions.filter((definition) => definition.function.name !== "ask_user");
-    }
     async execute(call) {
         const callId = String(call.id || "");
         const name = String(call.function?.name || "");
         this.pendingVisualContent.delete(callId);
         try {
+            // 监听器不会补发已发生的 abort：已取消的 signal 必须在产生任何副作用
+            // 之前短路，否则命令会照常 spawn 直到自然结束。
+            this.signal?.throwIfAborted();
             const argumentsValue = JSON.parse(typeof call.function?.arguments === "string"
                 ? call.function.arguments
                 : "{}");
@@ -452,29 +455,32 @@ export class ToolExecutor {
                 tool_call_id: callId,
                 content: json({
                     status: "error",
-                    tool: name,
-                    error: errorMessage(error),
+                    message: errorMessage(error),
                 }),
             };
         }
     }
     takeVisualMessage(toolCallIds) {
-        const content = [];
+        // 生产契约：同一组 tool call 的全部图片汇入一条 user message，
+        // 由一个 arena-system-message 文本 part 领头。
+        const images = [];
         for (const toolCallId of toolCallIds) {
             const parts = this.pendingVisualContent.get(toolCallId);
             this.pendingVisualContent.delete(toolCallId);
             if (parts)
-                content.push(...parts);
+                images.push(...parts);
         }
-        return content.length ? { role: "user", content } : undefined;
+        if (!images.length)
+            return undefined;
+        return {
+            role: "user",
+            content: [{ type: "text", text: visualIntroText }, ...images],
+        };
     }
     async dispatch(name, values, toolCallId) {
         switch (name) {
             case "bash":
-                return this.bash(String(values.command), String(values.cwd ||
-                    (this.workspaceContext
-                        ? path.resolve(this.workspaceContext.cwd)
-                        : "/home/user")), Number(values.timeout || 30));
+                return this.bash(String(values.command), String(values.cwd || "/home/user"), Number(values.timeout || 30));
             case "ask_user":
                 return this.askUser(values.questions, toolCallId);
             case "edit_file":
@@ -488,7 +494,7 @@ export class ToolExecutor {
             case "write_file":
                 return this.writeWorkspaceFile(String(values.path), String(values.content));
             case "image_search":
-                return this.imageSearch(String(values.query), Number(values.count), toolCallId);
+                return this.imageSearch(String(values.query), Number(values.count));
             case "present_file":
                 return this.presentFile(String(values.path));
             case "generate_image":
@@ -503,20 +509,20 @@ export class ToolExecutor {
         if (!raw)
             throw new Error("path must not be empty");
         let candidate;
-        if (!this.workspaceContext && (raw === "/home/user" || raw === "~")) {
+        if (raw === "/home/user" || raw === "~") {
             candidate = this.workspace;
         }
-        else if (!this.workspaceContext && raw.startsWith("/home/user/")) {
+        else if (raw.startsWith("/home/user/")) {
             candidate = path.join(this.workspace, raw.slice("/home/user/".length));
         }
-        else if (!this.workspaceContext && raw.startsWith("~/")) {
+        else if (raw.startsWith("~/")) {
             candidate = path.join(this.workspace, raw.slice(2));
         }
         else {
-            const defaultCwd = this.workspaceContext
-                ? path.resolve(this.workspaceContext.cwd)
-                : this.workspace;
-            candidate = path.isAbsolute(raw) ? raw : path.join(defaultCwd, raw);
+            // 相对路径解析到 /home/user，repo 模式暂同。未经裁决：tools.json 与
+            // repo 模式 system prompt 对相对路径根的说法矛盾，生产轨迹无法区分；
+            // 复刻脚本会把受影响的调用标记为 comparability hazard。
+            candidate = path.isAbsolute(raw) ? raw : path.join(this.workspace, raw);
         }
         const absolute = path.resolve(candidate);
         const lexicalRelative = path.relative(this.workspace, absolute);
@@ -542,24 +548,126 @@ export class ToolExecutor {
     relativePath(target) {
         return path.relative(this.workspaceReal, target).split(path.sep).join("/");
     }
+    virtualizeBashOutput(value) {
+        let virtualized = value;
+        const workspaceRoots = [...new Set([this.workspace, this.workspaceReal])]
+            .filter((root) => root !== path.parse(root).root)
+            .sort((left, right) => right.length - left.length);
+        for (const root of workspaceRoots) {
+            virtualized = virtualized.replaceAll(root, "/home/user");
+        }
+        return virtualized;
+    }
     async bash(command, cwd, timeoutSeconds) {
         const workdir = await this.confinedPath(cwd);
         if (!(await stat(workdir)).isDirectory()) {
             throw new Error(`cwd is not a directory: ${cwd}`);
         }
+        // Arena 对模型暴露的工作区固定为 /home/user；本地 harness 可能运行在任意
+        // 绝对路径。用环境变量替换虚拟根，并同步 HOME，使 bash 与文件工具看到
+        // 相同的文件系统布局。
+        const translatedCommand = command.replaceAll("/home/user", "\"$ARENA_WORKSPACE\"");
         return new Promise((resolve, reject) => {
-            const child = spawn("/bin/bash", ["-lc", command], {
+            const env = {
+                ...process.env,
+                HOME: this.workspace,
+                ARENA_WORKSPACE: this.workspace,
+                // 生产 sandbox 是 C collation（参考 find|sort 为逐字节序），宿主
+                // 常见 en_US.UTF-8 会翻转大小写次序；统一成 C.UTF-8 对齐生产。
+                LANG: "C.UTF-8",
+                LC_ALL: "C.UTF-8",
+            };
+            // 交互终端（node --test、npm 等）会向子进程注入强制着色变量，
+            // 管道输出被 ANSI 色码污染；生产轨迹无色码，剥离之。
+            delete env.FORCE_COLOR;
+            delete env.CLICOLOR_FORCE;
+            // detached：管道成员（npm、tail…）与 bash 同进程组。只杀 bash 会留下
+            // 孤儿持有 stdout/stderr 管道，close 永不触发，整个 turn 挂死；
+            // 必须杀整组，并在宽限期后强制结算兜底。
+            const child = spawn("/bin/bash", ["-lc", translatedCommand], {
                 cwd: workdir,
+                env,
                 stdio: ["ignore", "pipe", "pipe"],
+                detached: process.platform !== "win32",
             });
+            const startedAt = Date.now();
             let stdout = "";
             let stderr = "";
             let timedOut = false;
+            let settled = false;
+            let killRequested = false;
+            let forceSettle;
+            const killTree = (signal) => {
+                try {
+                    if (process.platform !== "win32" && child.pid) {
+                        process.kill(-child.pid, signal);
+                    }
+                    else {
+                        child.kill(signal);
+                    }
+                }
+                catch (error) {
+                    // ESRCH：组已消失。EPERM：Darwin 在组正被回收时对重复 kill 的
+                    // 返回值，同样视作已处理。
+                    const code = error.code;
+                    if (code !== "ESRCH" && code !== "EPERM")
+                        throw error;
+                }
+            };
+            const finish = (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                if (forceSettle)
+                    clearTimeout(forceSettle);
+                // 组长退出会立刻触发 close 并取消宽限定时器；取消/超时一旦请求过
+                // 击杀，就必须在结算时补一发组级 SIGKILL，否则忽略 TERM 且关闭了
+                // 继承管道的后台子进程会活过取消。正常退出不清场——模型可能有意
+                // 留下后台服务供后续调用使用。
+                if (killRequested)
+                    killTree("SIGKILL");
+                this.signal?.removeEventListener("abort", abort);
+                if (this.signal?.aborted) {
+                    reject(this.signal.reason || new Error("operation cancelled"));
+                    return;
+                }
+                // 生产契约：status 恒为 "completed"（包括非零退出码），超时无参考样本，
+                // 按最小猜测同样返回 completed + exit_code null，stderr 附超时说明。
+                if (timedOut) {
+                    stderr += (stderr ? "\n" : "") + `command exceeded ${timeoutSeconds}s`;
+                }
+                const out = capBashOutput(this.virtualizeBashOutput(stdout));
+                const err = capBashOutput(this.virtualizeBashOutput(stderr));
+                resolve({
+                    status: "completed",
+                    stderr: err.text,
+                    stdout: out.text,
+                    exit_code: timedOut ? null : code,
+                    duration_ms: Date.now() - startedAt,
+                    stderr_truncated: err.truncated,
+                    stdout_truncated: out.truncated,
+                });
+            };
+            // 宽限期结束时升级为组级 SIGKILL 再结算：abort 只发 SIGTERM，
+            // trap TERM 的进程会活过 Promise 拒绝并继续改写工作区。
+            const armForceSettle = () => {
+                forceSettle ??= setTimeout(() => {
+                    killTree("SIGKILL");
+                    finish(null);
+                }, 2000);
+            };
             const timeout = setTimeout(() => {
                 timedOut = true;
-                child.kill("SIGKILL");
+                killRequested = true;
+                killTree("SIGKILL");
+                armForceSettle();
             }, timeoutSeconds * 1000);
-            const abort = () => child.kill("SIGTERM");
+            const abort = () => {
+                killRequested = true;
+                killTree("SIGTERM");
+                armForceSettle();
+            };
             this.signal?.addEventListener("abort", abort, { once: true });
             child.stdout.on("data", (chunk) => {
                 stdout += chunk.toString("utf8");
@@ -567,78 +675,68 @@ export class ToolExecutor {
             child.stderr.on("data", (chunk) => {
                 stderr += chunk.toString("utf8");
             });
-            child.once("error", reject);
-            child.once("close", (code) => {
+            child.once("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
                 clearTimeout(timeout);
+                if (forceSettle)
+                    clearTimeout(forceSettle);
                 this.signal?.removeEventListener("abort", abort);
-                if (this.signal?.aborted) {
-                    reject(this.signal.reason || new Error("operation cancelled"));
-                    return;
-                }
-                if (timedOut) {
-                    resolve({
-                        status: "timeout",
-                        exit_code: null,
-                        stdout: "",
-                        stderr: `command exceeded ${timeoutSeconds}s`,
-                    });
-                    return;
-                }
-                resolve({
-                    status: code === 0 ? "success" : "error",
-                    exit_code: code,
-                    stdout,
-                    stderr,
-                });
+                reject(error);
             });
+            child.once("close", (code) => finish(code));
         });
     }
     async askUser(questions, toolCallId) {
         if (this.askUserHandler) {
             return this.askUserHandler(toolCallId, questions);
         }
-        // ask_user is not offered in non-interactive sessions; if the model still
-        // emits it (e.g. resumed history or a hallucinated call), report an error
-        // so the turn continues instead of stalling on needs_input.
         return {
-            status: "error",
-            tool: "ask_user",
-            error: "ask_user is unavailable in this non-interactive session. " +
-                "Proceed with reasonable defaults and state any assumptions you make.",
+            status: "needs_input",
+            questions,
+            message: "The current headless request cannot collect interactive input.",
         };
     }
     async editFile(rawPath, oldText, newText) {
         const target = await this.confinedPath(rawPath);
         const source = await readFile(target, "utf8");
-        let updated;
-        if (source.includes(oldText)) {
-            updated = source.replace(oldText, newText);
-        }
-        else {
-            const tokens = oldText.split(/\s+/).filter(Boolean);
-            const pattern = new RegExp(tokens.map(escapeRegExp).join("\\s+"));
-            if (!pattern.test(source)) {
-                return {
-                    status: "error",
-                    message: "Context not found. Read the file to verify the text exists.",
-                };
-            }
-            updated = source.replace(pattern, newText);
+        // 仅精确匹配：曾有空白容错回退，但 T1(b) 回放证实生产没有——case-003
+        // 四个 old_text 精确缺失的 edit 生产全部返回 Context not found，而回退
+        // 会静默改错文件；全部参考成功样本也都能走精确路径复现。
+        // 注意：spec/tools.json 的 edit_file description（与生产逐字一致，受
+        // T1(c) 门禁保护）声称支持 fuzzy matching——那是上游自身的描述与行为
+        // 不一致，按实测行为对齐，描述不改。见 TRAJECTORY_FIDELITY.md §5。
+        if (!source.includes(oldText)) {
+            return {
+                status: "error",
+                message: "Context not found. Read the file to verify the text exists.",
+            };
         }
-        await writeFile(target, updated, "utf8");
+        await writeFile(target, source.replace(oldText, newText), "utf8");
         return { status: "success", message: `Edited ${rawPath}.` };
     }
     async readWorkspaceFile(rawPath, toolCallId) {
         const target = await this.confinedPath(rawPath);
-        const data = await readFile(target);
+        let data;
+        try {
+            data = await readFile(target);
+        }
+        catch {
+            // 逐字对齐生产错误文案，路径按调用方原样回显。
+            return {
+                status: "error",
+                message: `Failed to read workspace file: ${rawPath}`,
+            };
+        }
         const extension = path.extname(target).toLowerCase();
         const kind = workspaceFileKind(target, data.subarray(0, 4096));
-        const relativePath = this.relativePath(target);
-        const result = {
-            status: "success",
-            path: relativePath,
-        };
         if (isStructuredDocument(target)) {
+            // 文档提取无参考样本（known-unknown），保留本地扩展键。
+            const result = {
+                status: "success",
+                path: this.relativePath(target),
+            };
             const extracted = await extractStructuredDocument(target, data, this.signal);
             result.content = extracted.content;
             result.mime_type =
@@ -655,34 +753,41 @@ export class ToolExecutor {
                 result.truncated = true;
             if (extracted.warning)
                 result.warning = extracted.warning;
+            return result;
         }
-        else if (kind === "text") {
-            result.content = decodeText(data);
+        if (kind === "text") {
+            const content = decodeText(data);
+            return {
+                kind: "text",
+                lines: content.split("\n").length,
+                size: Buffer.byteLength(content, "utf8"),
+                content,
+            };
         }
-        else {
-            const mimeType = mime.getType(target) ||
-                mimeTypes[extension] ||
-                "application/octet-stream";
-            result.mime_type = mimeType;
-            result.size = data.length;
-            if (kind === "image") {
-                if (data.length > 20 * 1024 * 1024) {
-                    throw new Error(`image exceeds 20 MB: ${rawPath}`);
-                }
-                result.content = imagePlaceholder;
-                this.pendingVisualContent.set(toolCallId, [
-                    {
-                        text: "<arena-system-message>" +
-                            `The image below is the genuine content returned by read_file for ${JSON.stringify(relativePath)}.` +
-                            "</arena-system-message>",
-                    },
-                    {
-                        image: `data:${mimeType};base64,${data.toString("base64")}`,
-                    },
-                ]);
+        const mimeType = mime.getType(target) ||
+            mimeTypes[extension] ||
+            "application/octet-stream";
+        if (kind === "image") {
+            if (data.length > 20 * 1024 * 1024) {
+                throw new Error(`image exceeds 20 MB: ${rawPath}`);
             }
+            this.pendingVisualContent.set(toolCallId, [
+                {
+                    type: "image_url",
+                    image_url: {
+                        url: `data:${mimeType};base64,${data.toString("base64")}`,
+                        detail: "auto",
+                    },
+                },
+            ]);
+            return [{ type: "text", text: imageResultPlaceholder }];
         }
-        return result;
+        return {
+            status: "success",
+            path: this.relativePath(target),
+            mime_type: mimeType,
+            size: data.length,
+        };
     }
     async writeWorkspaceFile(rawPath, content) {
         const target = await this.confinedPath(rawPath);
@@ -720,28 +825,25 @@ export class ToolExecutor {
         const searchResults = Array.isArray(searchInfo.search_results)
             ? searchInfo.search_results
             : [];
-        const choices = Array.isArray(output.choices) ? output.choices : [];
-        const answer = stringValue(record(record(choices[0]).message).content);
         const limit = { "1": 3, "2": 5, "3": 8 }[depth] || 5;
+        // 参考轨迹条目：{id, url, title, description[, pageAge]}；
+        // DashScope 无 pageAge，按可选键省略。
         return {
             status: "success",
-            query,
-            answer,
             results: searchResults.slice(0, limit).map((value, index) => {
                 const item = record(value);
                 return {
                     id: Number(item.index) || index + 1,
-                    title: stringValue(item.title),
                     url: stringValue(item.url),
-                    content: stringValue(item.content) ||
+                    title: stringValue(item.title),
+                    description: stringValue(item.content) ||
                         stringValue(item.snippet) ||
                         stringValue(item.summary),
-                    site_name: stringValue(item.site_name),
                 };
             }),
         };
     }
-    async imageSearch(query, count, toolCallId) {
+    async imageSearch(query, count) {
         const model = process.env.ARENA_IMAGE_SEARCH_MODEL || "qwen3.7-plus";
         const payload = await dashScopeJson("compatible", "/responses", {
             method: "POST",
@@ -770,13 +872,14 @@ export class ToolExecutor {
                 throw new Error("image_search returned malformed image results");
             }
         }
-        const images = [];
-        const searchId = toolCallId
-            .replace(/[^A-Za-z0-9_-]+/g, "-")
-            .replace(/^-+|-+$/g, "")
-            .slice(0, 96) || "search";
+        const saved = [];
+        // 参考轨迹命名：image-search/<query slug 前 40 字符>-<序号>.<扩展名>。
+        const slug = query
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .slice(0, 40);
         for (const value of results) {
-            if (images.length >= count)
+            if (saved.length >= count)
                 break;
             const item = record(value);
             const sourceUrl = stringValue(item.url) ||
@@ -794,13 +897,14 @@ export class ToolExecutor {
                     continue;
                 const normalizedType = contentType.split(";")[0]?.trim().toLowerCase();
                 const extension = Object.entries(mimeTypes).find(([, mime]) => mime === normalizedType)?.[0] || ".jpg";
-                const target = await this.confinedPath(`assets/image-search/${searchId}/result-${images.length + 1}${extension}`);
+                const target = await this.confinedPath(`image-search/${slug}-${saved.length + 1}${extension}`);
                 mkdirSync(path.dirname(target), { recursive: true });
                 await writeFile(target, await responseBytes(imageResponse));
-                images.push({
-                    path: this.relativePath(target),
-                    source_url: sourceUrl,
+                saved.push({
                     title: stringValue(item.title),
+                    file_path: this.relativePath(target),
+                    source_url: sourceUrl,
+                    thumbnail_url: stringValue(item.thumbnail_url) || sourceUrl,
                 });
             }
             catch (error) {
@@ -809,7 +913,7 @@ export class ToolExecutor {
                 // A single inaccessible search result should not fail the whole search.
             }
         }
-        return { status: "success", query, images };
+        return { status: "success", results: saved };
     }
     async presentFile(rawPath) {
         const target = await this.confinedPath(rawPath);
@@ -912,7 +1016,6 @@ export class ToolExecutor {
         return {
             status: "success",
             file_path: this.relativePath(target),
-            task_id: taskId,
         };
     }
     async generateSpeech(rawPath, text, language, voiceIdentity = {}) {