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

package/dist/code-tools.js

@@ -1,8 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { closeSync, existsSync, mkdirSync, openSync, realpathSync, } from "node:fs";
-import { chmod, mkdir, readFile, readdir, realpath, rm, stat, writeFile, } from "node:fs/promises";
-import { createConnection } from "node:net";
+import { mkdir, readFile, readdir, realpath, rm, stat, writeFile, } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
@@ -11,7 +10,11 @@ import addFormats from "ajv-formats";
 import { detect as detectEncoding } from "chardet";
 import iconv from "iconv-lite";
 import mime from "mime/lite";
+import { executeBraveWebSearch } from "./brave-search.js";
 import { FetchPageReader } from "./fetch-page.js";
+import { generatedImageBytesForExtension } from "./image.js";
+import { generateImageWithModelRouter, } from "./model-router-media.js";
+import { executeRoutifyWebFetch, routifyWebFetchEnabled, } from "./routify-web-fetch.js";
 import { toolDefinitions } from "./spec.js";
 const knownTextApplicationMimeTypes = new Set([
     "application/ecmascript",
@@ -387,69 +390,6 @@ function record(value) {
 function stringValue(value) {
     return typeof value === "string" ? value : "";
 }
-function dashScopeApiKey() {
-    const apiKey = process.env.DASHSCOPE_API_KEY;
-    if (!apiKey) {
-        throw new Error("DashScope tools require DASHSCOPE_API_KEY");
-    }
-    return apiKey;
-}
-function dashScopeRoot() {
-    return (process.env.DASHSCOPE_API_BASE ||
-        process.env.DASHSCOPE_BASE_URL ||
-        "https://dashscope.aliyuncs.com")
-        .replace(/\/+$/, "")
-        .replace(/\/(?:api\/v1|compatible-mode\/v1)$/i, "");
-}
-function dashScopeUrl(protocol, pathname) {
-    const prefix = protocol === "api" ? "/api/v1" : "/compatible-mode/v1";
-    const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
-    return `${dashScopeRoot()}${prefix}${normalized}`;
-}
-async function dashScopeFetch(protocol, pathname, init, label) {
-    const headers = new Headers(init.headers);
-    headers.set("authorization", `Bearer ${dashScopeApiKey()}`);
-    const maximumRetries = Math.max(0, Number(process.env.CODE_HARNESS_TOOL_MAX_RETRIES || 5));
-    for (let attempt = 0;; attempt += 1) {
-        const response = await fetch(dashScopeUrl(protocol, pathname), {
-            ...init,
-            headers,
-        });
-        if (response.ok)
-            return response;
-        const body = await response.text();
-        let detail = body;
-        try {
-            const payload = record(JSON.parse(body));
-            detail =
-                stringValue(payload.message) ||
-                    stringValue(record(payload.error).message) ||
-                    body;
-        }
-        catch {
-            // Keep the response text as the diagnostic.
-        }
-        const retryable = response.status === 429 || response.status >= 500;
-        if (!retryable || attempt >= maximumRetries) {
-            throw new Error(`${label} failed (${response.status} ${response.statusText}): ${detail.slice(0, 2000)}`);
-        }
-        const retryAfter = Number(response.headers.get("retry-after"));
-        const waitMs = Number.isFinite(retryAfter) && retryAfter > 0
-            ? Math.min(60_000, retryAfter * 1000)
-            : Math.min(30_000, 2_000 * 2 ** attempt);
-        await delay(waitMs, undefined, { signal: init.signal || undefined });
-    }
-}
-async function dashScopeJson(protocol, pathname, init, label) {
-    const response = await dashScopeFetch(protocol, pathname, init, label);
-    return record(await response.json());
-}
-function responseMessage(payload) {
-    return (stringValue(payload.message) ||
-        stringValue(record(payload.output).message) ||
-        stringValue(payload.code) ||
-        "unknown provider error");
-}
 function contentTypeForFile(filePath) {
     const extension = path.extname(filePath).toLowerCase();
     if ([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"].includes(extension)) {
@@ -604,13 +544,6 @@ function validationIssues(toolName, value, errors, definitions) {
     }
     return issues;
 }
-async function responseBytes(response, limit = 4 * 1024 * 1024) {
-    const bytes = Buffer.from(await response.arrayBuffer());
-    if (bytes.length > limit) {
-        throw new Error(`download exceeds ${limit} bytes`);
-    }
-    return bytes;
-}
 const defaultMediaCacheTtlMs = 24 * 60 * 60 * 1000;
 const mediaRequestInflight = new Map();
 let pexelsQuota;
@@ -1382,21 +1315,6 @@ export class CodeToolExecutor {
         return virtualized;
     }
     async fullStackBash(command, workdir) {
-        // The captured Full Stack sandbox exposes PostgreSQL and psql from the
-        // beginning of the session, not only after build_and_start. Materialize
-        // that baseline before every bash call so early drizzle/psql commands see
-        // the same environment. ensureFullStackDatabase is a cheap port check
-        // after the first call.
-        const databaseError = await this.ensureFullStackDatabase();
-        if (databaseError) {
-            return {
-                status: "error",
-                message: `Fullstack sandbox setup failed: ${databaseError}`,
-                stdout: "",
-                stderr: databaseError,
-            };
-        }
-        await this.preparePostgresCliShim();
         const configuredTimeout = Number(process.env.CODE_HARNESS_BASH_TIMEOUT_SECONDS || 300);
         const timeoutSeconds = Number.isFinite(configuredTimeout) && configuredTimeout > 0
             ? configuredTimeout
@@ -1415,128 +1333,6 @@ export class CodeToolExecutor {
         }
         return { status: "success", stdout, stderr };
     }
-    async portIsOpen(hostname, port, timeoutMs = 500) {
-        return new Promise((resolve) => {
-            const socket = createConnection({ host: hostname, port });
-            const finish = (open) => {
-                socket.removeAllListeners();
-                socket.destroy();
-                resolve(open);
-            };
-            socket.setTimeout(timeoutMs);
-            socket.once("connect", () => finish(true));
-            socket.once("error", () => finish(false));
-            socket.once("timeout", () => finish(false));
-        });
-    }
-    async fullStackDatabaseUrl() {
-        const envPath = path.join(this.workspaceReal, ".env");
-        let configured = process.env.DATABASE_URL || "";
-        try {
-            const source = await readFile(envPath, "utf8");
-            const match = source.match(/^\s*DATABASE_URL\s*=\s*([^\r\n]+)\s*$/m);
-            if (match?.[1])
-                configured = match[1].replace(/^['"]|['"]$/g, "");
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-        return new URL(configured || "postgresql://postgres:postgres@127.0.0.1:5432/app_db");
-    }
-    async ensureFullStackDatabase() {
-        const databaseUrl = await this.fullStackDatabaseUrl();
-        const hostname = databaseUrl.hostname;
-        const port = Number(databaseUrl.port || 5432);
-        const username = decodeURIComponent(databaseUrl.username || "postgres");
-        const password = decodeURIComponent(databaseUrl.password || "postgres");
-        const database = databaseUrl.pathname.replace(/^\//, "") || "app_db";
-        if (await this.portIsOpen(hostname, port))
-            return undefined;
-        if (!["127.0.0.1", "localhost", "::1"].includes(hostname)) {
-            return `PostgreSQL is not reachable at ${hostname}:${port}`;
-        }
-        let dockerInfo;
-        try {
-            dockerInfo = await this.runProcess("docker", ["info"], 15_000);
-        }
-        catch (error) {
-            return `PostgreSQL is not running and Docker is unavailable: ${errorMessage(error)}`;
-        }
-        if (dockerInfo.exitCode !== 0) {
-            return (dockerInfo.stderr.trim() ||
-                "PostgreSQL is not running and Docker is unavailable");
-        }
-        const containerName = this.postgresContainerName();
-        const inspection = await this.runProcess("docker", ["inspect", "-f", "{{.State.Running}}", containerName], 15_000);
-        let started;
-        if (inspection.exitCode === 0) {
-            started = inspection.stdout.trim() === "true"
-                ? { exitCode: 0, stdout: "", stderr: "" }
-                : await this.runProcess("docker", ["start", containerName], 60_000);
-        }
-        else {
-            started = await this.runProcess("docker", [
-                "run",
-                "-d",
-                "--name",
-                containerName,
-                "-e",
-                `POSTGRES_USER=${username}`,
-                "-e",
-                `POSTGRES_PASSWORD=${password}`,
-                "-e",
-                `POSTGRES_DB=${database}`,
-                "-p",
-                `127.0.0.1:${port}:5432`,
-                process.env.CODE_HARNESS_POSTGRES_IMAGE || "postgres:16-alpine",
-            ], 2 * 60_000);
-        }
-        if (started.exitCode !== 0) {
-            return started.stderr.trim() || "Failed to start PostgreSQL container";
-        }
-        for (let attempt = 0; attempt < 60; attempt += 1) {
-            if (await this.portIsOpen(hostname, port, 1000)) {
-                const ready = await this.runProcess("docker", [
-                    "exec",
-                    containerName,
-                    "pg_isready",
-                    "-U",
-                    username,
-                    "-d",
-                    database,
-                ], 5_000);
-                if (ready.exitCode === 0)
-                    return undefined;
-            }
-            await delay(500);
-        }
-        return `PostgreSQL did not become ready at ${hostname}:${port}`;
-    }
-    postgresContainerName() {
-        const digest = createHash("sha256")
-            .update(this.workspaceReal)
-            .digest("hex")
-            .slice(0, 12);
-        return `code-harness-postgres-${digest}`;
-    }
-    async preparePostgresCliShim() {
-        const containerName = this.postgresContainerName();
-        let inspection;
-        try {
-            inspection = await this.runProcess("docker", ["inspect", "-f", "{{.State.Running}}", containerName], 15_000);
-        }
-        catch {
-            return;
-        }
-        if (inspection.exitCode !== 0 || inspection.stdout.trim() !== "true")
-            return;
-        const binDirectory = path.join(this.workspaceReal, ".code-harness", "bin");
-        const wrapperPath = path.join(binDirectory, "psql");
-        await mkdir(binDirectory, { recursive: true });
-        await writeFile(wrapperPath, `#!/bin/sh\nexec docker exec -i ${containerName} psql "$@"\n`, "utf8");
-        await chmod(wrapperPath, 0o755);
-    }
     buildAndStartFailure(stage, message, logs) {
         return {
             status: "error",
@@ -1569,11 +1365,6 @@ export class CodeToolExecutor {
     }
     async buildAndStart() {
         const timeoutMs = Number(process.env.CODE_HARNESS_FULLSTACK_BUILD_TIMEOUT_MS || 300_000);
-        const databaseError = await this.ensureFullStackDatabase();
-        if (databaseError) {
-            return this.buildAndStartFailure("database", `Fullstack sandbox setup failed: ${databaseError}`, databaseError);
-        }
-        await this.preparePostgresCliShim();
         const nextBinary = path.join(this.workspaceReal, "node_modules", ".bin", "next");
         if (!existsSync(nextBinary)) {
             const installed = await this.runNpmProcess(["install"], timeoutMs);
@@ -1672,10 +1463,8 @@ export class CodeToolExecutor {
         return new Promise((resolve, reject) => {
             const env = {
                 ...process.env,
-                HOME: this.workspace,
                 ARENA_WORKSPACE: this.workspace,
                 CODE_HARNESS_WORKSPACE: this.workspace,
-                PATH: `${path.join(this.workspaceReal, ".code-harness", "bin")}${path.delimiter}${process.env.PATH || ""}`,
                 // 生产 sandbox 是 C collation（参考 find|sort 为逐字节序），宿主
                 // 常见 en_US.UTF-8 会翻转大小写次序；统一成 C.UTF-8 对齐生产。
                 LANG: "C.UTF-8",
@@ -1796,55 +1585,17 @@ export class CodeToolExecutor {
     async webSearch(query, depth) {
         const model = process.env.CODE_HARNESS_WEB_SEARCH_MODEL ||
             process.env.ARENA_WEB_SEARCH_MODEL ||
-            "qwen-plus";
-        const searchStrategy = depth === "1" ? "turbo" : "max";
-        const payload = await dashScopeJson("api", "/services/aigc/text-generation/generation", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({
-                model,
-                input: {
-                    messages: [{ role: "user", content: query }],
-                },
-                parameters: {
-                    enable_search: true,
-                    result_format: "message",
-                    search_options: {
-                        forced_search: true,
-                        enable_source: true,
-                        enable_citation: true,
-                        citation_format: "[<number>]",
-                        search_strategy: searchStrategy,
-                    },
-                },
-            }),
+            "brave.llm-context";
+        return executeBraveWebSearch(query, depth, {
+            model,
+            profile: "code-arena",
             signal: this.signal,
-        }, "web_search");
-        const output = record(payload.output);
-        const searchInfo = record(output.search_info);
-        const searchResults = Array.isArray(searchInfo.search_results)
-            ? searchInfo.search_results
-            : [];
-        const limit = { "1": 3, "2": 5, "3": 8 }[depth] || 5;
-        // 参考轨迹条目：{id, url, title, description[, pageAge]}；
-        // DashScope 无 pageAge，按可选键省略。
-        return {
-            status: "success",
-            results: searchResults.slice(0, limit).map((value, index) => {
-                const item = record(value);
-                return {
-                    id: Number(item.index) || index + 1,
-                    url: stringValue(item.url),
-                    title: stringValue(item.title),
-                    description: stringValue(item.content) ||
-                        stringValue(item.snippet) ||
-                        stringValue(item.summary),
-                };
-            }),
-        };
+        });
     }
     async webFetch(url, format) {
-        const result = await this.pageReader.readFormatted(url, format);
+        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"),
@@ -1986,15 +1737,15 @@ export class CodeToolExecutor {
         }
         this.generatedImageCount += 1;
         const target = await this.confinedPath(rawPath);
-        if (![".jpg", ".jpeg", ".png"].includes(path.extname(target).toLowerCase())) {
+        const extension = path.extname(target).toLowerCase();
+        if (![".jpg", ".jpeg", ".png"].includes(extension)) {
             throw new Error("file_path must end in .jpg, .jpeg, or .png");
         }
         mkdirSync(path.dirname(target), { recursive: true });
         const model = process.env.CODE_HARNESS_IMAGE_MODEL ||
             process.env.ARENA_IMAGE_MODEL ||
-            "qwen-image-2.0-pro";
-        const isQwenImage2 = model.startsWith("qwen-image-2.0");
-        const content = [];
+            "gemini-2.5-flash-image";
+        const references = [];
         for (const imagePath of images || []) {
             const source = await this.confinedPath(imagePath);
             const extension = path.extname(source).toLowerCase();
@@ -2006,97 +1757,22 @@ export class CodeToolExecutor {
             if (bytes.length > 20 * 1024 * 1024) {
                 throw new Error(`reference image exceeds 20 MB: ${imagePath}`);
             }
-            content.push({
-                image: `data:${mimeType};base64,${bytes.toString("base64")}`,
+            references.push({
+                bytes,
+                fileName: path.basename(source),
+                mimeType,
             });
         }
-        content.push({ text: prompt });
-        const parameters = {
+        const generated = await generateImageWithModelRouter({
+            images: references,
+            model,
+            prompt,
+            signal: this.signal,
             size: process.env.CODE_HARNESS_IMAGE_SIZE ||
                 process.env.ARENA_IMAGE_SIZE ||
-                (isQwenImage2 ? "2048*2048" : "2K"),
-            watermark: false,
-        };
-        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,
-            body: JSON.stringify({
-                model,
-                input: {
-                    messages: [{ role: "user", content }],
-                },
-                parameters,
-            }),
-            signal: this.signal,
-        }, "generate_image");
-        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 (!completed) {
-                throw new Error(`generate_image timed out waiting for task ${taskId}`);
-            }
-        }
-        if (!completed) {
-            throw new Error("generate_image returned no response");
-        }
-        const output = record(completed.output);
-        const choices = Array.isArray(output.choices) ? output.choices : [];
-        const message = record(record(choices[0]).message);
-        const generatedContent = Array.isArray(message.content)
-            ? message.content
-            : [];
-        const generated = generatedContent
-            .map(record)
-            .find((item) => typeof item.image === "string");
-        const legacyResults = Array.isArray(output.results) ? output.results : [];
-        const imageUrl = stringValue(generated?.image) ||
-            stringValue(record(legacyResults[0]).url);
-        if (!imageUrl) {
-            throw new Error("generate_image response did not include an image URL");
-        }
-        const imageResponse = await fetch(imageUrl, { signal: this.signal });
-        if (!imageResponse.ok) {
-            throw new Error(`image download failed (${imageResponse.status})`);
-        }
-        await writeFile(target, await responseBytes(imageResponse, 25 * 1024 * 1024));
+                "1024*1024",
+        });
+        await writeFile(target, await generatedImageBytesForExtension(generated.bytes, generated.mimeType, extension));
         return {
             status: "success",
             message: `Image saved to ${this.relativePath(target)}`,