@qwen-code/arena-agent 0.0.8-dev.5 → 0.0.9-dev.0

package/dist/tools.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, realpathSync } from "node:fs";
-import { readFile, readdir, realpath, stat, writeFile, } from "node:fs/promises";
+import { existsSync, mkdirSync, realpathSync, } from "node:fs";
+import { open, readFile, realpath, stat, writeFile, } from "node:fs/promises";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { Ajv } from "ajv";
@@ -10,7 +10,7 @@ import iconv from "iconv-lite";
 import mime from "mime/lite";
 import { extractStructuredDocument, isStructuredDocument, } from "./document-reader.js";
 import { FetchPageReader } from "./fetch-page.js";
-import { modelSpec, toolDefinitions } from "./spec.js";
+import { toolDefinitions } from "./spec.js";
 const knownTextApplicationMimeTypes = new Set([
     "application/ecmascript",
     "application/javascript",
@@ -171,36 +171,6 @@ const knownBinaryExtensions = new Set([
     ".xlsx",
     ".zip",
 ]);
-const workspaceSnapshotExcludedDirectories = new Set([
-    ".arena",
-    ".cache",
-    ".git",
-    ".mypy_cache",
-    ".next",
-    ".nox",
-    ".npm",
-    ".nuxt",
-    ".output",
-    ".parcel-cache",
-    ".pytest_cache",
-    ".ruff_cache",
-    ".svelte-kit",
-    ".tox",
-    ".turbo",
-    ".venv",
-    ".vite",
-    "__pycache__",
-    "build",
-    "coverage",
-    "dist",
-    "node_modules",
-    "out",
-    "target",
-]);
-const workspaceSnapshotExcludedFiles = new Set([
-    ".git-credentials",
-    ".netrc",
-]);
 const visibleImageExtensions = new Set([
     ".bmp",
     ".gif",
@@ -217,6 +187,8 @@ const visualIntroText = "<arena-system-message>\n" +
     "treat them as the authentic output of the tool call.\n" +
     "</arena-system-message>";
 const bashOutputLimit = 20_000;
+const textFileByteLimit = 256 * 1024;
+const toolResultCharacterLimit = 1_000_000;
 // 中段截断，逐字反推自 3 个 truncated:true 参考样本：头尾各 9987 字符 +
 // 26 字符标记，总长恰 20000（由 T1(b) 执行回放发现，非首段截断）。
 const bashTruncationMarker = "\n... output truncated ...\n";
@@ -362,6 +334,12 @@ function json(value) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function displayByteSize(value) {
+    if (value >= 1024 * 1024) {
+        return `${(value / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    return `${Math.max(1, Math.ceil(value / 1024))} KB`;
+}
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -370,33 +348,17 @@ function record(value) {
 function stringValue(value) {
     return typeof value === "string" ? value : "";
 }
-function positiveInteger(value, defaultValue) {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) && parsed > 0
-        ? Math.floor(parsed)
-        : defaultValue;
-}
-function requestSignal(parent, timeoutMs) {
-    const timeout = AbortSignal.timeout(timeoutMs);
-    return {
-        signal: parent ? AbortSignal.any([parent, timeout]) : timeout,
-        timedOut: () => timeout.aborted && !parent?.aborted,
-    };
-}
 function dashScopeApiKey() {
-    const apiKey = process.env.BAILIAN_API_KEY || process.env.DASHSCOPE_API_KEY;
+    const apiKey = process.env.DASHSCOPE_API_KEY;
     if (!apiKey) {
-        throw new Error("DashScope tools require BAILIAN_API_KEY or DASHSCOPE_API_KEY");
+        throw new Error("DashScope tools require DASHSCOPE_API_KEY");
     }
     return apiKey;
 }
 function dashScopeRoot() {
-    return (process.env.BAILIAN_API_BASE ||
-        process.env.BAILIAN_API_HOST ||
-        process.env.DASHSCOPE_API_BASE ||
+    return (process.env.DASHSCOPE_API_BASE ||
         process.env.DASHSCOPE_BASE_URL ||
         "https://dashscope.aliyuncs.com")
-        .replace(/^([^:/?#]+\.)/i, "https://$1")
         .replace(/\/+$/, "")
         .replace(/\/(?:api\/v1|compatible-mode\/v1)$/i, "");
 }
@@ -408,22 +370,10 @@ function dashScopeUrl(protocol, pathname) {
 async function dashScopeFetch(protocol, pathname, init, label) {
     const headers = new Headers(init.headers);
     headers.set("authorization", `Bearer ${dashScopeApiKey()}`);
-    const timeoutMs = positiveInteger(process.env.ARENA_TOOL_HTTP_TIMEOUT_MS, 60_000);
-    const request = requestSignal(init.signal, timeoutMs);
-    let response;
-    try {
-        response = await fetch(dashScopeUrl(protocol, pathname), {
-            ...init,
-            headers,
-            signal: request.signal,
-        });
-    }
-    catch (error) {
-        if (request.timedOut()) {
-            throw new Error(`${label} timed out after ${timeoutMs}ms`);
-        }
-        throw error;
-    }
+    const response = await fetch(dashScopeUrl(protocol, pathname), {
+        ...init,
+        headers,
+    });
     if (response.ok)
         return response;
     const body = await response.text();
@@ -464,7 +414,6 @@ export class ToolExecutor {
     validators = new Map();
     pendingVisualContent = new Map();
     askUserHandler;
-    deferUserInput;
     signal;
     workspaceContext;
     pageReader;
@@ -479,26 +428,25 @@ export class ToolExecutor {
         mkdirSync(this.workspace, { recursive: true });
         this.workspaceReal = realpathSync(this.workspace);
         this.askUserHandler = options.askUserHandler;
-        this.deferUserInput = options.deferUserInput === true;
-        this.askUserEnabled =
-            Boolean(options.askUserHandler) || this.deferUserInput;
+        this.askUserEnabled = Boolean(options.askUserHandler);
         this.signal = options.signal;
         this.workspaceContext = options.workspaceContext;
         this.pageReader = new FetchPageReader({ signal: options.signal });
         addFormats(this.ajv);
-        const toolNames = modelSpec().tools.map((definition) => definition.function.name);
-        for (const definition of toolDefinitions(this.workspaceContext, toolNames)) {
+        for (const definition of toolDefinitions(this.workspaceContext)) {
             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(toolNames) {
-        const definitions = toolDefinitions(this.workspaceContext, toolNames);
-        if (this.askUserEnabled)
-            return definitions;
-        return definitions.filter((definition) => definition.function.name !== "ask_user");
+    availableTools() {
+        let definitions = toolDefinitions(this.workspaceContext);
+        if (!this.askUserEnabled) {
+            definitions = definitions.filter((definition) => definition.function.name !== "ask_user");
+        }
+        const disallowed = new Set(this.config.disallowedTools || []);
+        return definitions.filter((definition) => !disallowed.has(definition.function.name));
     }
     async execute(call) {
         const callId = String(call.id || "");
@@ -508,6 +456,9 @@ export class ToolExecutor {
             // 监听器不会补发已发生的 abort：已取消的 signal 必须在产生任何副作用
             // 之前短路，否则命令会照常 spawn 直到自然结束。
             this.signal?.throwIfAborted();
+            if (this.config.disallowedTools?.includes(name)) {
+                throw new Error(`tool is disallowed: ${name}`);
+            }
             const argumentsValue = JSON.parse(typeof call.function?.arguments === "string"
                 ? call.function.arguments
                 : "{}");
@@ -521,10 +472,23 @@ export class ToolExecutor {
                 throw new Error(`invalid arguments: ${errors}`);
             }
             const result = await this.dispatch(name, argumentsValue, callId);
+            const content = typeof result === "string" ? result : json(result);
+            if (content.length > toolResultCharacterLimit) {
+                return {
+                    role: "tool",
+                    tool_call_id: callId,
+                    content: json({
+                        status: "error",
+                        message: `Tool result from ${name} (${content.length} characters) exceeds the ` +
+                            `maximum allowed size (${toolResultCharacterLimit} characters). ` +
+                            "Retry with narrower arguments or inspect the data in smaller portions.",
+                    }),
+                };
+            }
             return {
                 role: "tool",
                 tool_call_id: callId,
-                content: typeof result === "string" ? result : json(result),
+                content,
             };
         }
         catch (error) {
@@ -555,52 +519,6 @@ export class ToolExecutor {
             content: [{ text: visualIntroText }, ...images],
         };
     }
-    async workspaceSnapshot() {
-        const files = [];
-        let capturedBytes = 0;
-        const perFileLimit = Math.max(1024 * 1024, Number(process.env.ARENA_DB_FILE_LIMIT_BYTES || 8 * 1024 * 1024));
-        const totalLimit = Math.max(perFileLimit, Number(process.env.ARENA_DB_WORKSPACE_LIMIT_BYTES || 32 * 1024 * 1024));
-        const visit = async (directory) => {
-            if (files.length >= 2_000)
-                return;
-            const entries = await readdir(directory, { withFileTypes: true });
-            for (const entry of entries) {
-                if (files.length >= 2_000)
-                    break;
-                if (entry.isSymbolicLink())
-                    continue;
-                const target = path.join(directory, entry.name);
-                if (entry.isDirectory()) {
-                    if (!workspaceSnapshotExcludedDirectories.has(entry.name)) {
-                        await visit(target);
-                    }
-                    continue;
-                }
-                if (!entry.isFile() ||
-                    workspaceSnapshotExcludedFiles.has(entry.name)) {
-                    continue;
-                }
-                const metadata = await stat(target);
-                const relative = this.relativePath(target);
-                if (metadata.size > perFileLimit ||
-                    capturedBytes + metadata.size > totalLimit) {
-                    throw new Error(`workspace database snapshot limit exceeded at ${relative}`);
-                }
-                const data = await readFile(target);
-                capturedBytes += data.length;
-                const kind = workspaceFileKind(target, data.subarray(0, 4096));
-                const mimeType = mime.getType(target) || "application/octet-stream";
-                files.push({
-                    path: relative,
-                    content: kind === "text"
-                        ? decodeText(data)
-                        : `data:${mimeType};base64,${data.toString("base64")}`,
-                });
-            }
-        };
-        await visit(this.workspaceReal);
-        return files;
-    }
     async dispatch(name, values, toolCallId) {
         switch (name) {
             case "bash":
@@ -822,13 +740,6 @@ export class ToolExecutor {
         if (this.askUserHandler) {
             return this.askUserHandler(toolCallId, questions);
         }
-        if (this.deferUserInput) {
-            return {
-                status: "needs_input",
-                questions,
-                message: "The current request is waiting for interactive input.",
-            };
-        }
         // 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.
@@ -859,9 +770,23 @@ export class ToolExecutor {
     }
     async readWorkspaceFile(rawPath, toolCallId) {
         const target = await this.confinedPath(rawPath);
-        let data;
+        let fileSize;
+        let sample;
         try {
-            data = await readFile(target);
+            const metadata = await stat(target);
+            if (!metadata.isFile())
+                throw new Error("not a regular file");
+            fileSize = metadata.size;
+            sample = Buffer.alloc(Math.min(fileSize, 4096));
+            if (sample.length) {
+                const handle = await open(target, "r");
+                try {
+                    await handle.read(sample, 0, sample.length, 0);
+                }
+                finally {
+                    await handle.close();
+                }
+            }
         }
         catch {
             // 逐字对齐生产错误文案，路径按调用方原样回显。
@@ -871,7 +796,29 @@ export class ToolExecutor {
             };
         }
         const extension = path.extname(target).toLowerCase();
-        const kind = workspaceFileKind(target, data.subarray(0, 4096));
+        const kind = workspaceFileKind(target, sample);
+        if (kind === "text" && fileSize > textFileByteLimit) {
+            return {
+                status: "error",
+                message: `File content (${displayByteSize(fileSize)}) exceeds the maximum allowed size ` +
+                    `(${displayByteSize(textFileByteLimit)}). Use bash with sed/head/tail to read ` +
+                    "specific portions of the file, or grep/rg to search for specific content " +
+                    "instead of reading the whole file.",
+            };
+        }
+        if (kind === "image" && fileSize > 20 * 1024 * 1024) {
+            throw new Error(`image exceeds 20 MB: ${rawPath}`);
+        }
+        let data;
+        try {
+            data = await readFile(target);
+        }
+        catch {
+            return {
+                status: "error",
+                message: `Failed to read workspace file: ${rawPath}`,
+            };
+        }
         if (isStructuredDocument(target)) {
             // 文档提取无参考样本（known-unknown），保留本地扩展键。
             const result = {
@@ -909,15 +856,12 @@ export class ToolExecutor {
             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, [
                 {
                     image: `data:${mimeType};base64,${data.toString("base64")}`,
                 },
             ]);
-            return [{ text: imageResultPlaceholder }];
+            return [{ type: "text", text: imageResultPlaceholder }];
         }
         return {
             status: "success",
@@ -981,13 +925,13 @@ export class ToolExecutor {
         };
     }
     async imageSearch(query, count) {
-        const model = process.env.ARENA_IMAGE_SEARCH_MODEL || "qwen3.7-flash";
+        const model = process.env.ARENA_IMAGE_SEARCH_MODEL || "qwen3.7-plus";
         const payload = await dashScopeJson("compatible", "/responses", {
             method: "POST",
             headers: { "content-type": "application/json" },
             body: JSON.stringify({
                 model,
-                input: `Search the web for images matching this query and return image search results: ${query}`,
+                input: query,
                 tools: [{ type: "web_search_image" }],
             }),
             signal: this.signal,
@@ -1015,53 +959,40 @@ export class ToolExecutor {
             .toLowerCase()
             .replace(/[^a-z0-9]+/g, "-")
             .slice(0, 40);
-        const downloaded = await Promise.all(results.map(async (value) => {
+        for (const value of results) {
+            if (saved.length >= count)
+                break;
             const item = record(value);
             const sourceUrl = stringValue(item.url) ||
                 stringValue(item.original_url) ||
                 stringValue(item.image_url) ||
                 stringValue(item.thumbnail_url);
             if (!sourceUrl)
-                return undefined;
+                continue;
             try {
-                const download = requestSignal(this.signal, positiveInteger(process.env.ARENA_IMAGE_DOWNLOAD_TIMEOUT_MS, 15_000));
-                const imageResponse = await fetch(sourceUrl, {
-                    signal: download.signal,
-                });
+                const imageResponse = await fetch(sourceUrl, { signal: this.signal });
                 if (!imageResponse.ok)
-                    return undefined;
+                    continue;
                 const contentType = imageResponse.headers.get("content-type") || "image/jpeg";
                 if (!contentType.toLowerCase().startsWith("image/"))
-                    return undefined;
+                    continue;
                 const normalizedType = contentType.split(";")[0]?.trim().toLowerCase();
                 const extension = Object.entries(mimeTypes).find(([, mime]) => mime === normalizedType)?.[0] || ".jpg";
-                return {
+                const target = await this.confinedPath(`image-search/${slug}-${saved.length + 1}${extension}`);
+                mkdirSync(path.dirname(target), { recursive: true });
+                await writeFile(target, await responseBytes(imageResponse));
+                saved.push({
                     title: stringValue(item.title),
+                    file_path: this.relativePath(target),
                     source_url: sourceUrl,
                     thumbnail_url: stringValue(item.thumbnail_url) || sourceUrl,
-                    extension,
-                    bytes: await responseBytes(imageResponse),
-                };
+                });
             }
             catch (error) {
                 if (this.signal?.aborted)
                     throw error;
                 // A single inaccessible search result should not fail the whole search.
-                return undefined;
             }
-        }));
-        for (const image of downloaded) {
-            if (!image || saved.length >= count)
-                continue;
-            const target = await this.confinedPath(`image-search/${slug}-${saved.length + 1}${image.extension}`);
-            mkdirSync(path.dirname(target), { recursive: true });
-            await writeFile(target, image.bytes);
-            saved.push({
-                title: image.title,
-                file_path: this.relativePath(target),
-                source_url: image.source_url,
-                thumbnail_url: image.thumbnail_url,
-            });
         }
         return { status: "success", results: saved };
     }
@@ -1077,7 +1008,8 @@ export class ToolExecutor {
             throw new Error("file_path must end in .jpg, .jpeg, or .png");
         }
         mkdirSync(path.dirname(target), { recursive: true });
-        const model = process.env.ARENA_IMAGE_MODEL || "wan2.7-image-pro";
+        const model = process.env.ARENA_IMAGE_MODEL || "qwen-image-2.0-pro";
+        const isQwenImage2 = model.startsWith("qwen-image-2.0");
         const content = [];
         for (const imagePath of images || []) {
             const source = await this.confinedPath(imagePath);
@@ -1096,18 +1028,28 @@ export class ToolExecutor {
         }
         content.push({ text: prompt });
         const parameters = {
-            size: process.env.ARENA_IMAGE_SIZE || "2K",
-            n: 1,
+            size: process.env.ARENA_IMAGE_SIZE ||
+                (isQwenImage2 ? "2048*2048" : "2K"),
             watermark: false,
         };
-        if (!images?.length)
-            parameters.thinking_mode = true;
-        const submitted = await dashScopeJson("api", "/services/aigc/image-generation/generation", {
+        if (isQwenImage2) {
+            parameters.prompt_extend = true;
+        }
+        else {
+            parameters.n = 1;
+            if (!images?.length)
+                parameters.thinking_mode = true;
+        }
+        const headers = {
+            "content-type": "application/json",
+        };
+        if (!isQwenImage2)
+            headers["x-dashscope-async"] = "enable";
+        const submitted = await dashScopeJson("api", isQwenImage2
+            ? "/services/aigc/multimodal-generation/generation"
+            : "/services/aigc/image-generation/generation", {
             method: "POST",
-            headers: {
-                "content-type": "application/json",
-                "x-dashscope-async": "enable",
-            },
+            headers,
             body: JSON.stringify({
                 model,
                 input: {
@@ -1117,31 +1059,38 @@ export class ToolExecutor {
             }),
             signal: this.signal,
         }, "generate_image");
-        const taskId = stringValue(record(submitted.output).task_id);
-        if (!taskId) {
-            throw new Error(`generate_image returned no task_id: ${responseMessage(submitted)}`);
-        }
-        const timeoutMs = Number(process.env.DASHSCOPE_TASK_TIMEOUT_MS || 5 * 60 * 1000);
-        const pollIntervalMs = Number(process.env.DASHSCOPE_TASK_POLL_INTERVAL_MS || 1000);
-        const deadline = Date.now() + timeoutMs;
-        let completed;
-        while (Date.now() <= deadline) {
-            const task = await dashScopeJson("api", `/tasks/${encodeURIComponent(taskId)}`, { method: "GET", signal: this.signal }, "generate_image status");
-            const output = record(task.output);
-            const taskStatus = stringValue(output.task_status).toUpperCase();
-            if (taskStatus === "SUCCEEDED") {
-                completed = task;
-                break;
+        let completed = isQwenImage2
+            ? submitted
+            : undefined;
+        if (!isQwenImage2) {
+            const taskId = stringValue(record(submitted.output).task_id);
+            if (!taskId) {
+                throw new Error(`generate_image returned no task_id: ${responseMessage(submitted)}`);
+            }
+            const timeoutMs = Number(process.env.DASHSCOPE_TASK_TIMEOUT_MS || 5 * 60 * 1000);
+            const pollIntervalMs = Number(process.env.DASHSCOPE_TASK_POLL_INTERVAL_MS || 1000);
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() <= deadline) {
+                const task = await dashScopeJson("api", `/tasks/${encodeURIComponent(taskId)}`, { method: "GET", signal: this.signal }, "generate_image status");
+                const output = record(task.output);
+                const taskStatus = stringValue(output.task_status).toUpperCase();
+                if (taskStatus === "SUCCEEDED") {
+                    completed = task;
+                    break;
+                }
+                if (["FAILED", "CANCELED", "UNKNOWN"].includes(taskStatus)) {
+                    throw new Error(`generate_image task ${taskStatus}: ${responseMessage(task)}`);
+                }
+                if (Date.now() + pollIntervalMs > deadline)
+                    break;
+                await delay(pollIntervalMs, undefined, { signal: this.signal });
             }
-            if (["FAILED", "CANCELED", "UNKNOWN"].includes(taskStatus)) {
-                throw new Error(`generate_image task ${taskStatus}: ${responseMessage(task)}`);
+            if (!completed) {
+                throw new Error(`generate_image timed out waiting for task ${taskId}`);
             }
-            if (Date.now() + pollIntervalMs > deadline)
-                break;
-            await delay(pollIntervalMs, undefined, { signal: this.signal });
         }
         if (!completed) {
-            throw new Error(`generate_image timed out waiting for task ${taskId}`);
+            throw new Error("generate_image returned no response");
         }
         const output = record(completed.output);
         const choices = Array.isArray(output.choices) ? output.choices : [];
@@ -1156,7 +1105,7 @@ export class ToolExecutor {
         const imageUrl = stringValue(generated?.image) ||
             stringValue(record(legacyResults[0]).url);
         if (!imageUrl) {
-            throw new Error("generate_image task succeeded without an image URL");
+            throw new Error("generate_image response did not include an image URL");
         }
         const imageResponse = await fetch(imageUrl, { signal: this.signal });
         if (!imageResponse.ok) {