@qwen-code/arena-agent 0.0.10-dev.7 → 0.0.10-dev.8-test.0

package/dist/code-tools.js

@@ -13,7 +13,8 @@ import mime from "mime/lite";
 import { executeBraveWebSearch } from "./brave-search.js";
 import { FetchPageReader } from "./fetch-page.js";
 import { replaceFirstText, replaceUniqueText } from "./file-edit.js";
-import { generatedImageBytesForExtension } from "./image.js";
+import { detectedImageMimeType, generatedImageBytesForExtension } from "./image.js";
+import { supportsImageInput } from "./model-capabilities.js";
 import { generateImageWithModelRouter, } from "./model-router-media.js";
 import { executeRoutifyWebFetch, routifyWebFetchEnabled, } from "./routify-web-fetch.js";
 import { replayResponseFor } from "./replay-responses.js";
@@ -187,6 +188,42 @@ const visibleImageExtensions = new Set([
     ".png",
     ".webp",
 ]);
+const readableImageExtensions = new Set([".jpeg", ".jpg", ".png"]);
+const maximumReadableImageBytes = 10 * 1024 * 1024;
+function readableImageMimeType(data) {
+    if (data.length >= 8 &&
+        data.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return "image/png";
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return "image/jpeg";
+    return undefined;
+}
+function hasReadableImageStructure(data, mediaType) {
+    if (detectedImageMimeType(data) !== mediaType)
+        return false;
+    if (mediaType === "image/jpeg") {
+        return data.length >= 4 && data[data.length - 2] === 0xff && data[data.length - 1] === 0xd9;
+    }
+    if (data.readUInt32BE(16) === 0 || data.readUInt32BE(20) === 0)
+        return false;
+    let offset = 8;
+    let hasImageData = false;
+    while (offset + 12 <= data.length) {
+        const length = data.readUInt32BE(offset);
+        const end = offset + 12 + length;
+        if (end > data.length)
+            return false;
+        const type = data.toString("ascii", offset + 4, offset + 8);
+        if (offset === 8 && (type !== "IHDR" || length !== 13))
+            return false;
+        if (type === "IDAT")
+            hasImageData = true;
+        if (type === "IEND")
+            return length === 0 && hasImageData;
+        offset = end;
+    }
+    return false;
+}
 // All 39 successful, unmutated list_files captures use this exact order,
 // independently of whether the requested path is the project root or src/.
 // It is the seed manifest order, not an alphabetical/filesystem order.
@@ -232,6 +269,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";
@@ -382,6 +420,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);
 }
@@ -755,8 +801,8 @@ export class CodeToolExecutor {
             this.validators.set("apply_patch", this.ajv.compile(APPLY_PATCH_PARAMETERS));
         }
     }
-    // The tool schemas offered to the model for this session. Identical to the
-    // canonical trace set, adjusted for the selected workspace runtime.
+    // The tools offered to the model for this session, with captured schemas
+    // and descriptions adjusted for current capabilities and workspace runtime.
     availableTools() {
         return structuredClone(this.definitions);
     }
@@ -764,6 +810,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 || "");
@@ -772,40 +937,8 @@ export class CodeToolExecutor {
             // 监听器不会补发已发生的 abort：已取消的 signal 必须在产生任何副作用
             // 之前短路，否则命令会照常 spawn 直到自然结束。
             this.signal?.throwIfAborted();
-            const parsedArguments = JSON.parse(typeof call.function?.arguments === "string"
-                ? call.function.arguments
-                : "{}");
-            // React captures normalize a string-valued argument payload to an empty
-            // object before validating required fields (rather than echoing the string).
-            const argumentsValue = this.config.mode === "react" && typeof parsedArguments === "string"
-                ? {}
-                : 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;
-            }
+            const parsedArguments = JSON.parse(this.rawArguments(call));
+            const argumentsValue = this.normalizeArguments(name, parsedArguments);
             const validate = this.validators.get(name);
             if (!validate) {
                 return {
@@ -814,14 +947,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);
@@ -869,7 +1000,7 @@ export class CodeToolExecutor {
             return replayed.output;
         switch (name) {
             case "read_file":
-                return this.readCodeFile(String(values.path), Number(values.offset), Number(values.limit));
+                return this.readCodeFile(String(values.path), Number(values.offset), Number(values.limit), _toolCallId);
             case "create_file":
                 return this.createCodeFile(String(values.path), String(values.content));
             case "edit_file":
@@ -1043,7 +1174,7 @@ export class CodeToolExecutor {
         await visit(searchRoot);
         return files;
     }
-    async readCodeFile(rawPath, offset, limit) {
+    async readCodeFile(rawPath, offset, limit, toolCallId) {
         const target = await this.confinedPath(rawPath);
         let data;
         try {
@@ -1057,10 +1188,50 @@ export class CodeToolExecutor {
                 message: `File "${rawPath}" does not exist`,
             };
         }
+        if (readableImageExtensions.has(path.extname(target).toLowerCase())) {
+            const mediaType = readableImageMimeType(data);
+            if (!mediaType) {
+                return {
+                    status: "error",
+                    message: `"${rawPath}" is not a valid image — the file contents are not PNG or JPEG. Re-download or regenerate the file, then read it again.`,
+                };
+            }
+            if (!supportsImageInput(this.config)) {
+                return {
+                    status: "error",
+                    message: `This model cannot view images. Reference "${rawPath}" by its path instead.`,
+                };
+            }
+            if (data.length > maximumReadableImageBytes) {
+                return {
+                    status: "error",
+                    message: `Image "${rawPath}" is too large to view (${Math.round(data.length / 1024)} KB, max 10240 KB).`,
+                };
+            }
+            if (!hasReadableImageStructure(data, mediaType)) {
+                return {
+                    status: "error",
+                    message: `"${rawPath}" is not a valid image — the file contents are not PNG or JPEG. Re-download or regenerate the file, then read it again.`,
+                };
+            }
+            const relativePath = this.relativePath(target);
+            this.pendingVisualContent.set(toolCallId, [
+                { image: `data:${mediaType};base64,${data.toString("base64")}` },
+            ]);
+            return {
+                file: {
+                    content: `[Image file ${relativePath} (${Math.round(data.length / 1024)} KB, ${mediaType})]`,
+                    contentType: "text/plain",
+                    path: relativePath,
+                },
+                image: { mediaType, sizeBytes: data.length },
+                status: "success",
+            };
+        }
         if (workspaceFileKind(target, data.subarray(0, 4096)) !== "text") {
             return {
                 status: "error",
-                message: `File "${rawPath}" is not a supported text file`,
+                message: `Cannot read binary file "${rawPath}". Only text files and PNG/JPEG images are supported.`,
             };
         }
         const lines = decodeText(data).split("\n");
@@ -1478,14 +1649,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 &&
@@ -1493,8 +1665,9 @@ 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
@@ -1502,8 +1675,9 @@ export class CodeToolExecutor {
                         // 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 = contextBefore;
+                            if (contextBefore.length) {
+                                match.contextBefore = capGrepLines(contextBefore);
+                            }
                         }
                         const nextMatch = matchingLines[position + 1];
                         const end = Math.min(index + 1 + after, nextMatch ?? searchLineCount);
@@ -1511,15 +1685,16 @@ export class CodeToolExecutor {
                         if (nextMatch !== undefined && before > 0) {
                             contextAfter.push(...lines.slice(Math.max(end, index + 1, nextMatch - before), nextMatch));
                         }
-                        if (contextAfter.length)
-                            match.contextAfter = contextAfter;
+                        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);