@qwen-code/arena-agent 0.0.9-image-input-fallback.0 → 0.0.10-dev.0

package/dist/tools.js

@@ -2,7 +2,6 @@ import { spawn } from "node:child_process";
 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";
 import addFormats from "ajv-formats";
 import { detect as detectEncoding } from "chardet";
@@ -14,12 +13,15 @@ import { CodeToolExecutor } from "./code-tools.js";
 import { supportsImageInput } from "./config.js";
 import { extractStructuredDocument, isStructuredDocument, } from "./document-reader.js";
 import { FetchPageReader } from "./fetch-page.js";
-import { prepareImageForModel } from "./image.js";
+import { generatedImageBytesForExtension, prepareImageForModel, } from "./image.js";
 import { imageTextFromFallbackModel } from "./image-input-fallback.js";
 import { isCodeArenaMode } from "./mode.js";
+import { generateImageWithModelRouter, generateSpeechWithModelRouter, } from "./model-router-media.js";
+import { processManagerForWorkspace, } from "./process-manager.js";
 import { HttpModelClient } from "./provider.js";
 import { RoutifyFetchPageReader, routifyWebFetchEnabled, } from "./routify-web-fetch.js";
 import { toolDefinitions } from "./spec.js";
+import { voiceRegistryForWorkspace, } from "./voice-registry.js";
 const knownTextApplicationMimeTypes = new Set([
     "application/ecmascript",
     "application/javascript",
@@ -361,58 +363,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 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.
-    }
-    throw new Error(`${label} failed (${response.status} ${response.statusText}): ${detail.slice(0, 2000)}`);
-}
-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");
-}
 async function responseBytes(response, limit = 4 * 1024 * 1024) {
     const bytes = Buffer.from(await response.arrayBuffer());
     if (bytes.length > limit) {
@@ -432,16 +382,20 @@ class ArenaToolExecutor {
     workspaceContext;
     pageReader;
     routifyPageReader;
+    processManager;
+    voiceRegistry;
     ajv = new Ajv({ allErrors: true, strict: false });
     // ask_user needs a handler: TUI/WebUI collect real user input, while
-    // headless `-p` may delegate to a configured remote User Agent. Without a
-    // handler the tool is withheld rather than dead-ending on needs_input.
+    // headless `-p` may delegate to a configured remote User Agent. add_voice
+    // remains available without one and deterministically registers a fallback.
     askUserEnabled;
     constructor(config, options = {}) {
         this.config = config;
         this.workspace = path.resolve(config.workspace);
         mkdirSync(this.workspace, { recursive: true });
         this.workspaceReal = realpathSync(this.workspace);
+        this.processManager = processManagerForWorkspace(this.workspaceReal);
+        this.voiceRegistry = voiceRegistryForWorkspace(this.workspaceReal);
         this.askUserHandler = options.askUserHandler;
         this.askUserEnabled = Boolean(options.askUserHandler);
         if (config.imageInputFallbackModel?.trim()) {
@@ -461,7 +415,7 @@ class ArenaToolExecutor {
     }
     // 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 handler is wired.
+    // ask_user when no handler is wired. add_voice stays available headlessly.
     availableTools() {
         let definitions = toolDefinitions(this.workspaceContext);
         if (!this.askUserEnabled) {
@@ -557,6 +511,8 @@ class ArenaToolExecutor {
                         : "/home/user")), Number(values.timeout || 30));
             case "ask_user":
                 return this.askUser(values.questions, toolCallId, context);
+            case "add_voice":
+                return this.addVoice(String(values.text), String(values.language), values.voice_identity, toolCallId, context);
             case "edit_file":
                 return this.editFile(String(values.path), String(values.old_text), String(values.new_text));
             case "read_file":
@@ -573,10 +529,28 @@ class ArenaToolExecutor {
                 return this.imageSearch(String(values.query), Number(values.count));
             case "present_file":
                 return this.presentFile(String(values.path));
+            case "stop_process":
+                return this.processManager.stop(String(values.process_id));
+            case "start_process":
+                return this.startProcess(String(values.name || ""), String(values.command), String(values.cwd ||
+                    (this.workspaceContext
+                        ? path.resolve(this.workspaceContext.cwd)
+                        : "/home/user")), Number(values.startup_wait || 5));
             case "generate_image":
                 return this.generateImage(String(values.file_path), String(values.prompt), values.images);
             case "generate_speech":
-                return this.generateSpeech(String(values.file_path), String(values.text), String(values.language), values.voice_identity);
+                return this.generateSpeech(String(values.file_path), String(values.text), String(values.voice_id), values.language === undefined ? undefined : String(values.language));
+            case "get_process_output":
+                return this.processManager.get({
+                    processId: String(values.process_id),
+                    tailLines: Number(values.tail_lines || 200),
+                    waitFor: values.wait_for,
+                    waitPattern: values.wait_pattern === undefined
+                        ? undefined
+                        : String(values.wait_pattern),
+                    waitTimeoutSeconds: Number(values.wait_timeout || 60),
+                    signal: this.signal,
+                });
             default:
                 throw new Error(`unknown tool: ${name}`);
         }
@@ -585,12 +559,15 @@ class ArenaToolExecutor {
         if (!raw)
             throw new Error("path must not be empty");
         let candidate;
-        if (!this.workspaceContext && (raw === "/home/user" || raw === "~")) {
+        if (raw === "/home/user") {
             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 === "~") {
+            candidate = this.workspace;
+        }
         else if (!this.workspaceContext && raw.startsWith("~/")) {
             candidate = path.join(this.workspace, raw.slice(2));
         }
@@ -636,6 +613,17 @@ class ArenaToolExecutor {
         }
         return virtualized;
     }
+    sandboxEnvironment() {
+        const env = {
+            ...process.env,
+            ARENA_WORKSPACE: this.workspace,
+            LANG: "C.UTF-8",
+            LC_ALL: "C.UTF-8",
+        };
+        delete env.FORCE_COLOR;
+        delete env.CLICOLOR_FORCE;
+        return env;
+    }
     async bash(command, cwd, timeoutSeconds) {
         const workdir = await this.confinedPath(cwd);
         if (!(await stat(workdir)).isDirectory()) {
@@ -647,18 +635,7 @@ class ArenaToolExecutor {
             ? command
             : command.replaceAll("/home/user", "\"$ARENA_WORKSPACE\"");
         return new Promise((resolve, reject) => {
-            const env = {
-                ...process.env,
-                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;
+            const env = this.sandboxEnvironment();
             // detached：管道成员（npm、tail…）与 bash 同进程组。只杀 bash 会留下
             // 孤儿持有 stdout/stderr 管道，close 永不触发，整个 turn 挂死；
             // 必须杀整组，并在宽限期后强制结算兜底。
@@ -673,7 +650,6 @@ class ArenaToolExecutor {
             let stderr = "";
             let timedOut = false;
             let settled = false;
-            let killRequested = false;
             let forceSettle;
             const killTree = (signal) => {
                 try {
@@ -692,33 +668,26 @@ class ArenaToolExecutor {
                         throw error;
                 }
             };
-            const finish = (code) => {
+            const finish = (code, signal) => {
                 if (settled)
                     return;
                 settled = true;
                 clearTimeout(timeout);
                 if (forceSettle)
                     clearTimeout(forceSettle);
-                // 组长退出会立刻触发 close 并取消宽限定时器；取消/超时一旦请求过
-                // 击杀，就必须在结算时补一发组级 SIGKILL，否则忽略 TERM 且关闭了
-                // 继承管道的后台子进程会活过取消。正常退出不清场——模型可能有意
-                // 留下后台服务供后续调用使用。
-                if (killRequested)
-                    killTree("SIGKILL");
+                // bash is one-shot in v2. Any descendant left in the process group is
+                // cleaned up even when the shell itself exited normally; persistent
+                // servers belong in start_process.
+                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",
+                    status: timedOut ? "timeout" : signal ? "killed" : "completed",
                     stderr: err.text,
                     stdout: out.text,
                     exit_code: timedOut ? null : code,
@@ -732,17 +701,15 @@ class ArenaToolExecutor {
             const armForceSettle = () => {
                 forceSettle ??= setTimeout(() => {
                     killTree("SIGKILL");
-                    finish(null);
+                    finish(null, "SIGKILL");
                 }, 2000);
             };
             const timeout = setTimeout(() => {
                 timedOut = true;
-                killRequested = true;
                 killTree("SIGKILL");
                 armForceSettle();
             }, timeoutSeconds * 1000);
             const abort = () => {
-                killRequested = true;
                 killTree("SIGTERM");
                 armForceSettle();
             };
@@ -763,7 +730,24 @@ class ArenaToolExecutor {
                 this.signal?.removeEventListener("abort", abort);
                 reject(error);
             });
-            child.once("close", (code) => finish(code));
+            child.once("close", (code, signal) => finish(code, signal));
+        });
+    }
+    async startProcess(name, command, cwd, startupWaitSeconds) {
+        const workdir = await this.confinedPath(cwd);
+        if (!(await stat(workdir)).isDirectory()) {
+            throw new Error(`cwd is not a directory: ${cwd}`);
+        }
+        const translatedCommand = this.workspaceContext
+            ? command
+            : command.replaceAll("/home/user", '"$ARENA_WORKSPACE"');
+        return this.processManager.start({
+            name,
+            command: translatedCommand,
+            cwd: workdir,
+            startupWaitSeconds,
+            env: this.sandboxEnvironment(),
+            signal: this.signal,
         });
     }
     async askUser(questions, toolCallId, context) {
@@ -783,6 +767,58 @@ class ArenaToolExecutor {
                 "Proceed with reasonable defaults and state any assumptions you make.",
         };
     }
+    async addVoice(text, language, voiceIdentity = {}, toolCallId, context) {
+        if (!this.askUserHandler) {
+            const selection = this.voiceRegistry.registerVirtual(language, voiceIdentity);
+            return {
+                status: "success",
+                message: `Battle "${selection.battleId}": no interactive voice picker was ` +
+                    `available, so a default voice was selected. Pass voice_id ` +
+                    `"${selection.voiceId}" to generate_speech to speak with it.`,
+                voice_id: selection.voiceId,
+                battle_id: selection.battleId,
+                virtual: true,
+            };
+        }
+        const battle = await this.voiceRegistry.audition(text, language, voiceIdentity, this.signal);
+        const response = await this.askUserHandler(toolCallId, [
+            {
+                id: `voice-battle-${battle.battleId}`,
+                question: "Which voice should be used for this speaker?",
+                options: battle.candidates.map((candidate) => ({
+                    id: candidate.id,
+                    label: candidate.label,
+                    description: "Play the audition, then select this voice.",
+                    audioDataUrl: candidate.audioDataUrl,
+                })),
+                allowCustomResponse: false,
+            },
+        ], context
+            ? {
+                ...context,
+                signal: this.signal || context.signal,
+            }
+            : undefined);
+        if (response.status === "needs_input")
+            return response;
+        if (response.skipped === true) {
+            return { status: "error", message: "The user skipped voice selection." };
+        }
+        const answers = Array.isArray(response.answers) ? response.answers : [];
+        const selectedOptionId = record(answers[0]).selectedOptionId;
+        if (typeof selectedOptionId !== "string") {
+            throw new Error("voice selection did not choose a candidate");
+        }
+        const voiceId = this.voiceRegistry.register(battle, selectedOptionId);
+        return {
+            status: "success",
+            message: `Battle "${battle.battleId}": the user selected a voice. ` +
+                `Pass voice_id "${voiceId}" to generate_speech to speak with it. ` +
+                "Continue the task now — if you need another voice, call add_voice again immediately.",
+            voice_id: voiceId,
+            battle_id: battle.battleId,
+        };
+    }
     async editFile(rawPath, oldText, newText) {
         const target = await this.confinedPath(rawPath);
         const source = await readFile(target, "utf8");
@@ -1012,13 +1048,13 @@ class ArenaToolExecutor {
     }
     async generateImage(rawPath, prompt, images) {
         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.ARENA_IMAGE_MODEL || "qwen-image-2.0-pro";
-        const isQwenImage2 = model.startsWith("qwen-image-2.0");
-        const content = [];
+        const model = process.env.ARENA_IMAGE_MODEL || "gemini-2.5-flash-image";
+        const references = [];
         for (const imagePath of images || []) {
             const source = await this.confinedPath(imagePath);
             const extension = path.extname(source).toLowerCase();
@@ -1030,169 +1066,56 @@ class ArenaToolExecutor {
             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 = {
-            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,
-            }),
+        const generated = await generateImageWithModelRouter({
+            images: references,
+            model,
+            prompt,
             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));
+            size: process.env.ARENA_IMAGE_SIZE || "1024*1024",
+        });
+        await writeFile(target, await generatedImageBytesForExtension(generated.bytes, generated.mimeType, extension));
         return {
             status: "success",
             file_path: this.relativePath(target),
         };
     }
-    async generateSpeech(rawPath, text, language, voiceIdentity = {}) {
+    async generateSpeech(rawPath, text, voiceId, language) {
         const target = await this.confinedPath(rawPath);
         const extension = path.extname(target).toLowerCase();
         const format = {
             ".mp3": "mp3",
             ".wav": "wav",
+            ".ogg": "opus",
             ".opus": "opus",
         }[extension];
         if (!format) {
-            throw new Error("DashScope speech output supports .mp3, .wav, or .opus");
+            throw new Error("ModelRouter Doubao TTS output supports .mp3, .wav, .ogg, or .opus");
         }
         mkdirSync(path.dirname(target), { recursive: true });
-        const model = process.env.ARENA_SPEECH_MODEL || "qwen-audio-3.0-tts-flash";
-        const feminine = voiceIdentity.gender !== "masculine";
-        const primaryLanguage = language.toLowerCase().split(/[-_]/)[0] || "";
-        const voices = primaryLanguage === "en"
-            ? feminine
-                ? ["loongeva_v3.6", "longanhuan_v3.6"]
-                : ["loongjohn", "longjielidou_v3.6"]
-            : feminine
-                ? ["longanhuan_v3.6"]
-                : ["longjielidou_v3.6"];
-        const requestedIndex = Math.max(0, Math.trunc(Number(voiceIdentity.index || 0)));
-        const voice = process.env.DASHSCOPE_SPEECH_VOICE ||
-            voices[requestedIndex % voices.length] ||
-            voices[0];
-        const supportedHints = new Set([
-            "ar",
-            "de",
-            "en",
-            "es",
-            "fil",
-            "fr",
-            "id",
-            "it",
-            "ja",
-            "ko",
-            "ms",
-            "pt",
-            "ru",
-            "th",
-            "vi",
-            "zh",
-        ]);
-        const input = {
-            text,
-            voice,
-            format,
-            sample_rate: 24000,
-        };
-        if (supportedHints.has(primaryLanguage)) {
-            input.language_hints = [primaryLanguage];
-        }
-        const payload = await dashScopeJson("api", "/services/audio/tts/SpeechSynthesizer", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ model, input }),
-            signal: this.signal,
-        }, "generate_speech");
-        const audioUrl = stringValue(record(record(payload.output).audio).url);
-        if (!audioUrl) {
-            throw new Error(`generate_speech returned no audio URL: ${responseMessage(payload)}`);
+        const registered = this.voiceRegistry.resolve(voiceId);
+        if (!registered) {
+            throw new Error(`unknown voice_id: ${voiceId}. Call add_voice and use the returned voice_id.`);
         }
-        const audioResponse = await fetch(audioUrl, { signal: this.signal });
-        if (!audioResponse.ok) {
-            throw new Error(`audio download failed (${audioResponse.status})`);
+        if (language &&
+            language.toLowerCase().split(/[-_]/)[0] !==
+                registered.language.toLowerCase().split(/[-_]/)[0]) {
+            throw new Error(`voice ${voiceId} was registered for ${registered.language}; ` +
+                `register a voice for ${language} with add_voice`);
         }
-        await writeFile(target, await responseBytes(audioResponse, 25 * 1024 * 1024));
+        const voice = process.env.ARENA_SPEECH_VOICE || registered.providerVoice;
+        await writeFile(target, await generateSpeechWithModelRouter({
+            format,
+            model: process.env.ARENA_SPEECH_MODEL || "doubao-tts",
+            signal: this.signal,
+            text,
+            voice,
+        }));
         return {
             status: "success",
             file_path: this.relativePath(target),