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

package/dist/tools.js

@@ -2,19 +2,26 @@ 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";
 import iconv from "iconv-lite";
 import mime from "mime/lite";
 import { AskUserHandlerError } from "./ask-user.js";
+import { executeBraveImageSearch, executeBraveWebSearch, } from "./brave-search.js";
 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 { 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",
@@ -356,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) {
@@ -422,24 +377,37 @@ class ArenaToolExecutor {
     validators = new Map();
     pendingVisualContent = new Map();
     askUserHandler;
+    imageInputFallbackClient;
     signal;
     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()) {
+            this.imageInputFallbackClient =
+                options.modelClient || new HttpModelClient(config);
+        }
         this.signal = options.signal;
         this.workspaceContext = options.workspaceContext;
         this.pageReader = new FetchPageReader({ signal: options.signal });
+        this.routifyPageReader = new RoutifyFetchPageReader({
+            signal: options.signal,
+        });
         addFormats(this.ajv);
         for (const definition of toolDefinitions(this.workspaceContext)) {
             this.validators.set(definition.function.name, this.ajv.compile(definition.function.parameters));
@@ -447,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) {
@@ -543,12 +511,16 @@ 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":
                 return this.readWorkspaceFile(String(values.path), toolCallId);
             case "fetch_page":
-                return this.pageReader.read(String(values.url), Number(values.chunkIndex || 0));
+                return routifyWebFetchEnabled()
+                    ? this.routifyPageReader.read(String(values.url), Number(values.chunkIndex || 0))
+                    : this.pageReader.read(String(values.url), Number(values.chunkIndex || 0));
             case "web_search":
                 return this.webSearch(String(values.query), String(values.depth));
             case "write_file":
@@ -557,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}`);
         }
@@ -569,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));
         }
@@ -620,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()) {
@@ -631,19 +635,7 @@ class ArenaToolExecutor {
             ? command
             : command.replaceAll("/home/user", "\"$ARENA_WORKSPACE\"");
         return new Promise((resolve, reject) => {
-            const env = {
-                ...process.env,
-                HOME: this.workspace,
-                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 挂死；
             // 必须杀整组，并在宽限期后强制结算兜底。
@@ -658,7 +650,6 @@ class ArenaToolExecutor {
             let stderr = "";
             let timedOut = false;
             let settled = false;
-            let killRequested = false;
             let forceSettle;
             const killTree = (signal) => {
                 try {
@@ -677,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,
@@ -717,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();
             };
@@ -748,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) {
@@ -768,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");
@@ -827,7 +878,11 @@ class ArenaToolExecutor {
         if (kind === "image" && fileSize > 20 * 1024 * 1024) {
             throw new Error(`image exceeds 20 MB: ${rawPath}`);
         }
-        if (kind === "image" && !supportsImageInput(this.config)) {
+        const mainModelSupportsImages = kind === "image" ? supportsImageInput(this.config) : false;
+        const fallbackModel = mainModelSupportsImages
+            ? undefined
+            : this.config.imageInputFallbackModel?.trim();
+        if (kind === "image" && !mainModelSupportsImages && !fallbackModel) {
             return unsupportedImageResult(path.basename(target));
         }
         let data;
@@ -877,9 +932,37 @@ class ArenaToolExecutor {
             mimeTypes[extension] ||
             "application/octet-stream";
         if (kind === "image") {
+            const prepared = await prepareImageForModel(data, mimeType);
+            if (!prepared.dataUri) {
+                return {
+                    status: "error",
+                    message: `Image could not be provided to the model: ${rawPath} ` +
+                        `(${prepared.omittedReason || "exceeds the inline image limits"}).`,
+                };
+            }
+            if (fallbackModel) {
+                if (!this.imageInputFallbackClient) {
+                    throw new Error("fallback image model client is unavailable");
+                }
+                const content = await imageTextFromFallbackModel(this.imageInputFallbackClient, {
+                    model: fallbackModel,
+                    fileName: this.relativePath(target),
+                    mimeType: prepared.mimeType || mimeType,
+                    dataUri: prepared.dataUri,
+                    signal: this.signal,
+                });
+                return {
+                    kind: "text",
+                    source_kind: "image",
+                    path: this.relativePath(target),
+                    lines: content.split("\n").length,
+                    size: Buffer.byteLength(content, "utf8"),
+                    content,
+                };
+            }
             this.pendingVisualContent.set(toolCallId, [
                 {
-                    image: `data:${mimeType};base64,${data.toString("base64")}`,
+                    image: prepared.dataUri,
                 },
             ]);
             return [{ type: "text", text: imageResultPlaceholder }];
@@ -898,82 +981,13 @@ class ArenaToolExecutor {
         return { status: "success" };
     }
     async webSearch(query, depth) {
-        const 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,
-                    },
-                },
-            }),
-            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),
-                };
-            }),
-        };
+        return executeBraveWebSearch(query, depth, { signal: this.signal });
     }
     async imageSearch(query, count) {
-        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: query,
-                tools: [{ type: "web_search_image" }],
-            }),
+        const payload = await executeBraveImageSearch(query, count, {
             signal: this.signal,
-        }, "image_search");
-        const output = Array.isArray(payload.output) ? payload.output : [];
-        const toolCall = output
-            .map(record)
-            .find((item) => item.type === "web_search_image_call");
-        let results = [];
-        if (toolCall?.output) {
-            try {
-                const parsed = typeof toolCall.output === "string"
-                    ? JSON.parse(toolCall.output)
-                    : toolCall.output;
-                if (Array.isArray(parsed))
-                    results = parsed;
-            }
-            catch {
-                throw new Error("image_search returned malformed image results");
-            }
-        }
+        });
+        const results = Array.isArray(payload.results) ? payload.results : [];
         const saved = [];
         // 参考轨迹命名：image-search/<query slug 前 40 字符>-<序号>.<扩展名>。
         const slug = query
@@ -984,35 +998,44 @@ class ArenaToolExecutor {
             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);
+            const properties = record(item.properties);
+            const thumbnail = record(item.thumbnail);
+            const sourceUrl = stringValue(properties.url) || stringValue(thumbnail.src);
+            const thumbnailUrl = stringValue(thumbnail.src) || sourceUrl;
             if (!sourceUrl)
                 continue;
-            try {
-                const imageResponse = await fetch(sourceUrl, { signal: this.signal });
-                if (!imageResponse.ok)
-                    continue;
-                const contentType = imageResponse.headers.get("content-type") || "image/jpeg";
-                if (!contentType.toLowerCase().startsWith("image/"))
-                    continue;
-                const normalizedType = contentType.split(";")[0]?.trim().toLowerCase();
-                const extension = Object.entries(mimeTypes).find(([, mime]) => mime === normalizedType)?.[0] || ".jpg";
-                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,
-                });
-            }
-            catch (error) {
-                if (this.signal?.aborted)
-                    throw error;
-                // A single inaccessible search result should not fail the whole search.
+            const downloadUrls = [...new Set([sourceUrl, thumbnailUrl])];
+            for (const downloadUrl of downloadUrls) {
+                try {
+                    const imageResponse = await fetch(downloadUrl, {
+                        signal: this.signal,
+                    });
+                    if (!imageResponse.ok)
+                        continue;
+                    const contentType = imageResponse.headers.get("content-type") || "image/jpeg";
+                    if (!contentType.toLowerCase().startsWith("image/"))
+                        continue;
+                    const normalizedType = contentType
+                        .split(";")[0]
+                        ?.trim()
+                        .toLowerCase();
+                    const extension = Object.entries(mimeTypes).find(([, mime]) => mime === normalizedType)?.[0] || ".jpg";
+                    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: thumbnailUrl,
+                    });
+                    break;
+                }
+                catch (error) {
+                    if (this.signal?.aborted)
+                        throw error;
+                    // Try the Brave proxy thumbnail when the original is inaccessible.
+                }
             }
         }
         return { status: "success", results: saved };
@@ -1025,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();
@@ -1043,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 registered = this.voiceRegistry.resolve(voiceId);
+        if (!registered) {
+            throw new Error(`unknown voice_id: ${voiceId}. Call add_voice and use the returned voice_id.`);
         }
-        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 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),