@qwen-code/arena-agent 0.0.10-dev.6 → 0.0.10-dev.8

package/dist/code-tools.js

@@ -12,11 +12,13 @@ import iconv from "iconv-lite";
 import mime from "mime/lite";
 import { executeBraveWebSearch } from "./brave-search.js";
 import { FetchPageReader } from "./fetch-page.js";
-import { replaceUniqueText } from "./file-edit.js";
+import { replaceFirstText, replaceUniqueText } from "./file-edit.js";
 import { generatedImageBytesForExtension } from "./image.js";
 import { generateImageWithModelRouter, } from "./model-router-media.js";
 import { executeRoutifyWebFetch, routifyWebFetchEnabled, } from "./routify-web-fetch.js";
+import { replayResponseFor } from "./replay-responses.js";
 import { toolDefinitions } from "./spec.js";
+import { boundedWebFetchResult, truncateCodeArenaText } from "./web-fetch-output.js";
 const knownTextApplicationMimeTypes = new Set([
     "application/ecmascript",
     "application/javascript",
@@ -230,6 +232,7 @@ const visualIntroText = "<code-harness-system-message>\n" +
     "</code-harness-system-message>";
 const bashOutputLimit = 20_000;
 const lintOutputLimit = 10_000;
+const grepLineCharacterLimit = 2_000;
 // 中段截断，逐字反推自 3 个 truncated:true 参考样本：头尾各 9987 字符 +
 // 26 字符标记，总长恰 20000（由 T1(b) 执行回放发现，非首段截断）。
 const bashTruncationMarker = "\n... output truncated ...\n";
@@ -380,6 +383,14 @@ function workspaceFileKind(filePath, sample) {
 function json(value) {
     return JSON.stringify(value);
 }
+function capGrepLine(value) {
+    // Production captures cap every returned grep line independently. This is
+    // intentionally a prefix without a marker, including for the matching line.
+    return value.slice(0, grepLineCharacterLimit);
+}
+function capGrepLines(values) {
+    return values.map(capGrepLine);
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -451,9 +462,14 @@ function matchesGlob(filePath, pattern) {
                 matcher.test(path.posix.basename(normalized))));
     });
 }
-function packageNameIsSafe(value) {
+function packageNameIsSafe(value, mode) {
     if (!value || value.startsWith("-") || /\s/.test(value))
         return false;
+    if (mode === "react") {
+        // React captures reject version ranges before invoking npm, while accepting
+        // exact versions and tags such as latest. Keep other modes' validator intact.
+        return /^(?:@[\w.-]+\/)?[\w.-]+(?:@[\w.+-]+)?$/.test(value);
+    }
     return /^(?:@[\w.-]+\/)?[\w.-]+(?:@(?:[\w*^<>=|.+-]+))?$/.test(value);
 }
 function valueAtPath(value, instancePath) {
@@ -757,6 +773,125 @@ export class CodeToolExecutor {
         const names = this.definitions.map((tool) => tool.function.name);
         return `Model tried to call unavailable tool '${name}'. Available tools: ${names.join(", ")}.`;
     }
+    rawArguments(call) {
+        return typeof call.function?.arguments === "string"
+            ? call.function.arguments
+            : "{}";
+    }
+    normalizeArguments(name, parsedArguments) {
+        // Keep the parsed value available to checkpoint hooks while applying the
+        // same captured runtime defaults to the independent dispatch value.
+        const argumentsValue = (this.config.mode === "react" && typeof parsedArguments === "string"
+            ? {}
+            : structuredClone(parsedArguments));
+        // The captured provider advertises these fields as required, but its
+        // runtime still applies the documented defaults when a model omits
+        // them. Preserve the byte-identical outgoing schema while matching the
+        // observed execution behavior.
+        if (name === "read_file") {
+            argumentsValue.offset ??= 1;
+            argumentsValue.limit ??= 2000;
+        }
+        else if (name === "list_files" || name === "glob_files") {
+            argumentsValue.path ??= "";
+        }
+        else if (this.config.mode === "full-stack" && name === "bash" &&
+            argumentsValue && typeof argumentsValue === "object" &&
+            !Array.isArray(argumentsValue) && argumentsValue.workdir === undefined) {
+            argumentsValue.workdir = "";
+        }
+        else if (name === "grep_files") {
+            argumentsValue.path ??= "";
+            argumentsValue.glob ??= "";
+            argumentsValue.output_mode ??= "content";
+            argumentsValue["-i"] ??= false;
+            argumentsValue["-B"] ??= 0;
+            argumentsValue["-A"] ??= 0;
+            argumentsValue["-C"] ??= 0;
+            argumentsValue.context ??= 0;
+        }
+        return argumentsValue;
+    }
+    validationMessage(name, value, validate) {
+        if (validate(value))
+            return undefined;
+        const issues = validationIssues(name, value, validate.errors || [], this.definitions);
+        return (`Invalid input for tool ${name}: Type validation failed: ` +
+            `Value: ${JSON.stringify(value)}.\n` +
+            `Error message: ${JSON.stringify(issues, null, 2)}`);
+    }
+    inspect(call) {
+        const id = String(call.id || "");
+        const name = String(call.function?.name || "");
+        const rawArguments = this.rawArguments(call);
+        const validate = this.validators.get(name);
+        if (!validate) {
+            let parsedArguments = undefined;
+            let parsed = false;
+            try {
+                parsedArguments = JSON.parse(rawArguments);
+                parsed = true;
+            }
+            catch {
+                // Tool-name validation takes precedence. Parsing is best-effort here
+                // only so a valid argument payload remains available to the hook.
+            }
+            return {
+                id,
+                name,
+                rawArguments,
+                ...(parsed ? { arguments: parsedArguments } : {}),
+                validation: "unknown_tool",
+                validationMessage: this.unavailableToolMessage(name),
+            };
+        }
+        let parsedArguments;
+        try {
+            parsedArguments = JSON.parse(rawArguments);
+        }
+        catch (error) {
+            return {
+                id,
+                name,
+                rawArguments,
+                validation: "invalid_json",
+                validationMessage: `Invalid input for tool ${name}: JSON parsing failed: Text: ` +
+                    `${rawArguments}.\nError message: ${errorMessage(error)}`,
+            };
+        }
+        let argumentsValue;
+        try {
+            argumentsValue = this.normalizeArguments(name, parsedArguments);
+        }
+        catch (error) {
+            return {
+                id,
+                name,
+                rawArguments,
+                arguments: parsedArguments,
+                validation: "invalid_arguments",
+                validationMessage: errorMessage(error),
+            };
+        }
+        const validationMessage = this.validationMessage(name, argumentsValue, validate);
+        if (validationMessage !== undefined) {
+            return {
+                id,
+                name,
+                rawArguments,
+                arguments: parsedArguments,
+                validation: "invalid_arguments",
+                validationMessage,
+            };
+        }
+        return {
+            id,
+            name,
+            rawArguments,
+            arguments: parsedArguments,
+            validation: "valid",
+        };
+    }
     async execute(call, _context) {
         const callId = String(call.id || "");
         const name = String(call.function?.name || "");
@@ -765,30 +900,8 @@ export class CodeToolExecutor {
             // 监听器不会补发已发生的 abort：已取消的 signal 必须在产生任何副作用
             // 之前短路，否则命令会照常 spawn 直到自然结束。
             this.signal?.throwIfAborted();
-            const argumentsValue = JSON.parse(typeof call.function?.arguments === "string"
-                ? call.function.arguments
-                : "{}");
-            // The captured provider advertises these fields as required, but its
-            // runtime still applies the documented defaults when a model omits
-            // them. Preserve the byte-identical outgoing schema while matching the
-            // observed execution behavior.
-            if (name === "read_file") {
-                argumentsValue.offset ??= 1;
-                argumentsValue.limit ??= 2000;
-            }
-            else if (name === "list_files" || name === "glob_files") {
-                argumentsValue.path ??= "";
-            }
-            else if (name === "grep_files") {
-                argumentsValue.path ??= "";
-                argumentsValue.glob ??= "";
-                argumentsValue.output_mode ??= "content";
-                argumentsValue["-i"] ??= false;
-                argumentsValue["-B"] ??= 0;
-                argumentsValue["-A"] ??= 0;
-                argumentsValue["-C"] ??= 0;
-                argumentsValue.context ??= 0;
-            }
+            const parsedArguments = JSON.parse(this.rawArguments(call));
+            const argumentsValue = this.normalizeArguments(name, parsedArguments);
             const validate = this.validators.get(name);
             if (!validate) {
                 return {
@@ -797,14 +910,12 @@ export class CodeToolExecutor {
                     content: this.unavailableToolMessage(name),
                 };
             }
-            if (!validate(argumentsValue)) {
-                const issues = validationIssues(name, argumentsValue, validate.errors || [], this.definitions);
+            const validationMessage = this.validationMessage(name, argumentsValue, validate);
+            if (validationMessage !== undefined) {
                 return {
                     role: "tool",
                     tool_call_id: callId,
-                    content: `Invalid input for tool ${name}: Type validation failed: ` +
-                        `Value: ${JSON.stringify(argumentsValue)}.\n` +
-                        `Error message: ${JSON.stringify(issues, null, 2)}`,
+                    content: validationMessage,
                 };
             }
             const result = await this.dispatch(name, argumentsValue, callId);
@@ -843,6 +954,13 @@ export class CodeToolExecutor {
         };
     }
     async dispatch(name, values, _toolCallId) {
+        // Replay mode (CODE_HARNESS_REPLAY_RESPONSES set): serve recorded outputs
+        // verbatim for nondeterministic tools (web_search/web_fetch/fetch_media/…)
+        // so replayed sessions stay offline and deterministic. Unlisted calls fall
+        // through to real execution.
+        const replayed = replayResponseFor(name, values);
+        if (replayed)
+            return replayed.output;
         switch (name) {
             case "read_file":
                 return this.readCodeFile(String(values.path), Number(values.offset), Number(values.limit));
@@ -1064,7 +1182,9 @@ export class CodeToolExecutor {
             status: "success",
             file: {
                 path: this.relativePath(target),
-                content: `${numbered}\n\n${footer}`,
+                content: this.config.mode === "react"
+                    ? truncateCodeArenaText(`${numbered}\n\n${footer}`)
+                    : `${numbered}\n\n${footer}`,
                 contentType: contentTypeForFile(target),
             },
             totalLines: lines.length,
@@ -1147,15 +1267,24 @@ export class CodeToolExecutor {
                 message: `File "${rawPath}" does not exist`,
             };
         }
-        const edited = replaceUniqueText(source, context, replacement, {
+        // React replaces the first exact occurrence, including when an indented
+        // context also occurs on a later, more deeply indented line. Keep the
+        // existing uniqueness check for fuzzy fallback and the other modes.
+        const replace = this.config.mode === "react" && context.length > 0 && source.includes(context)
+            ? replaceFirstText : replaceUniqueText;
+        const edited = replace(source, context, replacement, {
             whitespaceInsensitiveMultiline: true,
+            whitespaceInsensitiveSingleLine: this.config.mode === "react",
+            preserveNewlines: this.config.mode === "react",
         });
         if (edited === undefined) {
             // Captured sessions re-issue an edit after compaction or a retry. The
             // provider reports success without touching the file when the context
             // is already gone and the replacement is in place (f39 re-issues four
             // dashboard edits this way).
-            if (replacement && source.includes(replacement)) {
+            // That retry behavior comes from Full Stack captures. React still
+            // reports Context not found even when the replacement is present.
+            if (this.config.mode !== "react" && replacement && source.includes(replacement)) {
                 return this.mutationResult("Edited", rawPath);
             }
             return {
@@ -1198,6 +1327,19 @@ export class CodeToolExecutor {
             }
             current?.lines.push(line);
         }
+        if (this.config.mode === "react") {
+            // React parses duplicate operation paths before applying any writes.
+            // In particular, Delete + Add of the same file is an Add duplicate.
+            const seen = new Set();
+            for (const operation of operations) {
+                const target = await this.confinedPath(operation.path);
+                if (seen.has(target)) {
+                    const label = operation.kind[0].toUpperCase() + operation.kind.slice(1);
+                    return { status: "error", message: `${label} File Error: Duplicate Path: ${operation.path}` };
+                }
+                seen.add(target);
+            }
+        }
         for (const operation of operations) {
             const target = await this.confinedPath(operation.path);
             if (operation.kind === "add") {
@@ -1313,6 +1455,11 @@ export class CodeToolExecutor {
         return { status: "success" };
     }
     async listCodeFiles(rawPath) {
+        if (this.config.mode === "react" && rawPath === "/")
+            rawPath = ".";
+        if (this.config.mode === "react" && (path.isAbsolute(rawPath) || rawPath.includes(".."))) {
+            return { status: "error", message: "Path must be relative to project root (no absolute paths or '..' traversal)" };
+        }
         const target = await this.confinedPath(rawPath || ".");
         if (!(await this.existsWithExactCase(rawPath || ".")) ||
             !existsSync(target)) {
@@ -1321,7 +1468,8 @@ export class CodeToolExecutor {
         const files = this.orderListedFiles(await this.walkFiles(target));
         return {
             status: "success",
-            files: files.map((filePath) => ({ path: filePath })),
+            files: (this.config.mode === "react" ? files.slice(0, 500) : files)
+                .map((filePath) => ({ path: filePath })),
         };
     }
     async grepCodeFiles(values) {
@@ -1408,8 +1556,10 @@ export class CodeToolExecutor {
                 continue;
             }
             const lines = content.split("\n");
+            const searchLineCount = this.config.mode === "react" && lines.at(-1) === ""
+                ? lines.length - 1 : lines.length;
             const matchingLines = [];
-            for (let index = 0; index < lines.length; index += 1) {
+            for (let index = 0; index < searchLineCount; index += 1) {
                 if (expression.test(lines[index]))
                     matchingLines.push(index);
             }
@@ -1422,14 +1572,15 @@ export class CodeToolExecutor {
                     const match = {
                         path: relative,
                         lineNumber: index + 1,
-                        lineContent: lines[index],
+                        lineContent: capGrepLine(lines[index]),
                     };
                     if (groupedContext) {
                         const contextBefore = position === 0
                             ? lines.slice(Math.max(0, index - before), index)
                             : previousAfter;
-                        if (contextBefore.length > 0)
-                            match.contextBefore = contextBefore;
+                        if (contextBefore.length > 0) {
+                            match.contextBefore = capGrepLines(contextBefore);
+                        }
                         const nextMatch = matchingLines[position + 1] ?? lines.length;
                         previousAfter = lines.slice(index + 1, Math.min(index + 1 + contextSpan, nextMatch));
                         if (nextMatch === lines.length &&
@@ -1437,15 +1588,36 @@ export class CodeToolExecutor {
                             index + 1 + contextSpan >= lines.length) {
                             previousAfter = previousAfter.slice(0, -1);
                         }
-                        if (previousAfter.length > 0)
-                            match.contextAfter = previousAfter;
+                        if (previousAfter.length > 0) {
+                            match.contextAfter = capGrepLines(previousAfter);
+                        }
+                    }
+                    else if (this.config.mode === "react") {
+                        // The captured adapter attaches context lines to the preceding
+                        // match, even across ripgrep group separators. Only a file's first
+                        // match receives contextBefore. Do not duplicate overlapping groups.
+                        if (position === 0 && before > 0) {
+                            const contextBefore = lines.slice(Math.max(0, index - before), index);
+                            if (contextBefore.length) {
+                                match.contextBefore = capGrepLines(contextBefore);
+                            }
+                        }
+                        const nextMatch = matchingLines[position + 1];
+                        const end = Math.min(index + 1 + after, nextMatch ?? searchLineCount);
+                        const contextAfter = lines.slice(index + 1, end);
+                        if (nextMatch !== undefined && before > 0) {
+                            contextAfter.push(...lines.slice(Math.max(end, index + 1, nextMatch - before), nextMatch));
+                        }
+                        if (contextAfter.length) {
+                            match.contextAfter = capGrepLines(contextAfter);
+                        }
                     }
                     else {
                         if (before > 0) {
-                            match.contextBefore = lines.slice(Math.max(0, index - before), index);
+                            match.contextBefore = capGrepLines(lines.slice(Math.max(0, index - before), index));
                         }
                         if (after > 0) {
-                            match.contextAfter = lines.slice(index + 1, index + 1 + after);
+                            match.contextAfter = capGrepLines(lines.slice(index + 1, index + 1 + after));
                         }
                     }
                     matches.push(match);
@@ -1495,7 +1667,7 @@ export class CodeToolExecutor {
             return { status: "success", paths: [], truncated: false };
         }
         const allPaths = files
-            .filter((filePath) => matchesGlob(path.relative(target, filePath).split(path.sep).join("/"), pattern))
+            .filter((filePath) => matchesGlob(path.relative(target, filePath).split(path.sep).join("/"), pattern) || (this.config.mode === "react" && matchesGlob(this.relativePath(filePath), pattern)))
             .map((filePath) => this.relativePath(filePath));
         return {
             status: "success",
@@ -1568,11 +1740,11 @@ export class CodeToolExecutor {
         });
     }
     async installNpmPackages(packages) {
-        const invalid = packages.find((packageName) => !packageNameIsSafe(packageName));
+        const invalid = packages.find((packageName) => !packageNameIsSafe(packageName, this.config.mode));
         if (invalid) {
             return {
                 status: "error",
-                message: `Invalid package name: ${invalid}`,
+                message: `Invalid package name: ${this.config.mode === "react" ? JSON.stringify(invalid) : invalid}`,
             };
         }
         const args = ["install", "-S"];
@@ -1611,11 +1783,15 @@ export class CodeToolExecutor {
         };
     }
     async fullStackBash(command, workdir) {
+        const cwd = workdir.trim() || ".";
+        if (path.isAbsolute(cwd) || cwd.includes("..")) {
+            throw new Error(`Invalid workdir: ${cwd}. Commands run from the project root by default. Only use workdir for relative subdirectories, never absolute paths.`);
+        }
         const configuredTimeout = Number(process.env.CODE_HARNESS_BASH_TIMEOUT_SECONDS || 300);
         const timeoutSeconds = Number.isFinite(configuredTimeout) && configuredTimeout > 0
             ? configuredTimeout
             : 300;
-        const result = await this.bash(command, workdir.trim() || ".", timeoutSeconds);
+        const result = await this.bash(command, cwd, timeoutSeconds);
         const exitCode = result.exit_code;
         const stdout = String(result.stdout || "");
         const stderr = String(result.stderr || "");
@@ -1886,11 +2062,7 @@ export class CodeToolExecutor {
         const result = routifyWebFetchEnabled()
             ? await executeRoutifyWebFetch(url, format, { signal: this.signal })
             : await this.pageReader.readFormatted(url, format);
-        return {
-            status: "success",
-            title: String(result.title || "No Title Found"),
-            content: String(result.content || ""),
-        };
+        return boundedWebFetchResult(result);
     }
     async pexelsRequest(pathname, parameters) {
         const apiKey = process.env.PEXELS_API_KEY;
@@ -1929,7 +2101,7 @@ export class CodeToolExecutor {
             },
         });
     }
-    mapPexelsPhotos(payload) {
+    mapPexelsPhotos(payload, orientation) {
         const photos = Array.isArray(payload.photos) ? payload.photos : [];
         return photos.map((value) => {
             const photo = record(value);
@@ -1938,12 +2110,14 @@ export class CodeToolExecutor {
                 type: "image",
                 id: Number(photo.id),
                 pexelsUrl: stringValue(photo.url),
-                recommendedUrl: stringValue(source.large2x) ||
+                recommendedUrl: (orientation === "landscape" || orientation === "portrait"
+                    ? stringValue(source[orientation]) : "") ||
+                    stringValue(source.large2x) ||
                     stringValue(source.large) ||
                     stringValue(source.original),
-                thumbnailUrl: stringValue(source.medium) ||
-                    stringValue(source.small) ||
-                    stringValue(source.tiny),
+                thumbnailUrl: stringValue(source.tiny) ||
+                    stringValue(source.medium) ||
+                    stringValue(source.small),
                 width: Number(photo.width),
                 height: Number(photo.height),
                 creatorName: stringValue(photo.photographer),
@@ -1963,20 +2137,29 @@ export class CodeToolExecutor {
             const files = Array.isArray(video.video_files)
                 ? video.video_files.map(record)
                 : [];
-            const preferred = files.find((item) => stringValue(item.quality) === "hd") ||
-                files[0] ||
-                {};
+            // Captures contain full-resolution HD/UHD files. A quality label alone
+            // does not order renditions; compare their actual pixel dimensions.
+            const playable = files.filter((item) => stringValue(item.file_type) === "video/mp4" && stringValue(item.link));
+            const preferred = playable.sort((left, right) => (Number(right.width) || 0) * (Number(right.height) || 0) -
+                (Number(left.width) || 0) * (Number(left.height) || 0))[0] || files[0] || {};
             return {
                 type: "video",
                 id: Number(video.id),
                 pexelsUrl: stringValue(video.url),
                 recommendedUrl: stringValue(preferred.link),
-                thumbnailUrl: stringValue(pictures[0]?.picture),
+                thumbnailUrl: stringValue(video.image) || stringValue(pictures[0]?.picture),
                 width: Number(video.width),
                 height: Number(video.height),
                 duration: Number(video.duration),
                 creatorName: stringValue(user.name),
                 creatorUrl: stringValue(user.url),
+                videoFile: {
+                    url: stringValue(preferred.link),
+                    width: Number(preferred.width),
+                    height: Number(preferred.height),
+                    ...(preferred.quality !== undefined ? { quality: preferred.quality } : {}),
+                    fileType: stringValue(preferred.file_type),
+                },
             };
         });
     }
@@ -1994,7 +2177,7 @@ export class CodeToolExecutor {
         if (mediaType === "image" || mediaType === "both") {
             const photos = await this.pexelsRequest("/v1/search", common);
             totalResults += Number(photos.total_results || 0);
-            photoResults = this.mapPexelsPhotos(photos);
+            photoResults = this.mapPexelsPhotos(photos, orientation);
         }
         if (mediaType === "video" || mediaType === "both") {
             const videos = await this.pexelsRequest("/v1/videos/search", common);
@@ -2016,13 +2199,20 @@ export class CodeToolExecutor {
     }
     async fetchMedia(query, mediaType, count, orientation, size, locale) {
         const requestedCount = Math.min(10, Math.max(1, Math.trunc(count)));
-        return this.fetchMediaFromPexels(query, mediaType, requestedCount, orientation, size, locale);
+        try {
+            return await this.fetchMediaFromPexels(query, mediaType, requestedCount, orientation, size, locale);
+        }
+        catch (error) {
+            throw new Error(`Media fetch failed: ${errorMessage(error)}`);
+        }
     }
     async generateImage(rawPath, prompt, images) {
         if (this.generatedImageCount >= 10) {
             return {
                 status: "error",
-                message: "generate_image can be used at most 10 times per session",
+                message: this.config.mode === "react"
+                    ? "Failed to generate image: Image generation limit of 10 reached for this session. Use CSS gradients, SVG, or placeholder images for remaining visuals."
+                    : "generate_image can be used at most 10 times per session",
             };
         }
         this.generatedImageCount += 1;