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

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",
@@ -347,6 +349,180 @@ function json(value) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function jsonPointerPath(instancePath) {
+    if (!instancePath)
+        return [];
+    return instancePath
+        .slice(1)
+        .split("/")
+        .map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"))
+        .map((part) => (/^(0|[1-9]\d*)$/.test(part) ? Number(part) : part));
+}
+function valueAtPath(value, pathParts) {
+    let current = value;
+    for (const part of pathParts) {
+        if (current === null || typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function zodTypeName(type) {
+    return type === "integer" ? "number" : type;
+}
+function receivedType(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+function arenaValidationIssue(error, value) {
+    const pathParts = jsonPointerPath(error.instancePath);
+    if (error.keyword === "required") {
+        const missingProperty = String(error.params.missingProperty);
+        const parentSchema = error.parentSchema;
+        const expected = zodTypeName(parentSchema?.properties?.[missingProperty]?.type || "unknown");
+        return {
+            expected,
+            code: "invalid_type",
+            path: [...pathParts, missingProperty],
+            message: `Invalid input: expected ${expected}, received undefined`,
+        };
+    }
+    if (error.keyword === "type") {
+        const expected = zodTypeName(String(error.params.type));
+        return {
+            expected,
+            code: "invalid_type",
+            path: pathParts,
+            message: `Invalid input: expected ${expected}, received ` +
+                receivedType(valueAtPath(value, pathParts)),
+        };
+    }
+    if (error.keyword === "maxLength" || error.keyword === "minLength") {
+        const tooBig = error.keyword === "maxLength";
+        const limitKey = tooBig ? "maximum" : "minimum";
+        const limit = Number(error.params.limit);
+        return {
+            origin: "string",
+            code: tooBig ? "too_big" : "too_small",
+            [limitKey]: limit,
+            inclusive: true,
+            path: pathParts,
+            message: `${tooBig ? "Too big" : "Too small"}: expected string to have ` +
+                `${tooBig ? "<=" : ">="}${limit} characters`,
+        };
+    }
+    if (error.keyword === "maximum" || error.keyword === "minimum") {
+        const tooBig = error.keyword === "maximum";
+        const limitKey = tooBig ? "maximum" : "minimum";
+        const limit = Number(error.params.limit);
+        return {
+            origin: "number",
+            code: tooBig ? "too_big" : "too_small",
+            [limitKey]: limit,
+            inclusive: true,
+            path: pathParts,
+            message: `${tooBig ? "Too big" : "Too small"}: expected number to be ` +
+                `${tooBig ? "<=" : ">="}${limit}`,
+        };
+    }
+    if (error.keyword === "maxItems" || error.keyword === "minItems") {
+        const tooBig = error.keyword === "maxItems";
+        const limitKey = tooBig ? "maximum" : "minimum";
+        const limit = Number(error.params.limit);
+        return {
+            origin: "array",
+            code: tooBig ? "too_big" : "too_small",
+            [limitKey]: limit,
+            inclusive: true,
+            path: pathParts,
+            message: `${tooBig ? "Too big" : "Too small"}: expected array to have ` +
+                `${tooBig ? "<=" : ">="}${limit} items`,
+        };
+    }
+    if (error.keyword === "enum") {
+        const values = error.params.allowedValues;
+        return {
+            code: "invalid_value",
+            values,
+            path: pathParts,
+            message: `Invalid option: expected one of ${values
+                .map((item) => JSON.stringify(item))
+                .join("|")}`,
+        };
+    }
+    if (error.keyword === "format") {
+        return {
+            origin: "string",
+            code: "invalid_format",
+            format: error.params.format === "uri" ? "url" : error.params.format,
+            path: pathParts,
+            message: error.params.format === "uri" ? "Invalid URL" : "Invalid string",
+        };
+    }
+    return {
+        code: "custom",
+        path: pathParts,
+        message: error.message || "Invalid input",
+    };
+}
+function arenaValidationIssues(error, value) {
+    const issues = [arenaValidationIssue(error, value)];
+    if (error.keyword !== "type" || error.params.type !== "array")
+        return issues;
+    const pathParts = jsonPointerPath(error.instancePath);
+    const received = valueAtPath(value, pathParts);
+    if (typeof received !== "string")
+        return issues;
+    const parentSchema = error.parentSchema;
+    const maximum = parentSchema?.maxItems;
+    if (typeof maximum === "number" && received.length > maximum) {
+        issues.push({
+            origin: "string",
+            code: "too_big",
+            maximum,
+            inclusive: true,
+            path: pathParts,
+            message: `Too big: expected string to have <=${maximum} characters`,
+        });
+    }
+    const minimum = parentSchema?.minItems;
+    if (typeof minimum === "number" && received.length < minimum) {
+        issues.push({
+            origin: "string",
+            code: "too_small",
+            minimum,
+            inclusive: true,
+            path: pathParts,
+            message: `Too small: expected string to have >=${minimum} characters`,
+        });
+    }
+    return issues;
+}
+function arenaValidationError(toolName, value, errors) {
+    const issues = (errors || []).flatMap((error) => arenaValidationIssues(error, value));
+    return (`Invalid input for tool ${toolName}: Type validation failed: Value: ` +
+        `${JSON.stringify(value)}.\nError message: ${JSON.stringify(issues, null, 2)}`);
+}
+function arenaJsonParsingError(toolName, text, error) {
+    return (`Invalid input for tool ${toolName}: JSON parsing failed: Text: ${text}.\n` +
+        `Error message: ${errorMessage(error)}`);
+}
+function unavailableToolError(toolName, availableToolNames) {
+    return (`Model tried to call unavailable tool '${toolName}'. Available tools: ` +
+        `${[...availableToolNames, "compact"].join(", ")}.`);
+}
+function prefixedFailure(prefix, message) {
+    return message.startsWith(prefix) ? message : `${prefix}${message}`;
+}
+function fetchPageFailure(message) {
+    const status = message.match(/(?:fetch_page|Firecrawl|Jina Reader) failed \((\d{3})\b/i)?.[1];
+    return status
+        ? `Failed to fetch page (HTTP ${status})`
+        : "Failed to fetch page";
+}
 function displayByteSize(value) {
     if (value >= 1024 * 1024) {
         return `${(value / (1024 * 1024)).toFixed(1)} MB`;
@@ -361,58 +537,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 +556,27 @@ class ArenaToolExecutor {
     workspaceContext;
     pageReader;
     routifyPageReader;
-    ajv = new Ajv({ allErrors: true, strict: false });
+    processManager;
+    voiceRegistry;
+    ajv = new Ajv({
+        allErrors: true,
+        strict: false,
+        verbose: true,
+        // The captured runtime uses Zod object parsing: unknown object keys are
+        // stripped before dispatch instead of being emitted as validation issues.
+        removeAdditional: "all",
+    });
     // 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()) {
@@ -455,13 +590,20 @@ class ArenaToolExecutor {
             signal: options.signal,
         });
         addFormats(this.ajv);
+        // WHATWG URL parsing matches the captured fetch_page behavior. ajv-formats'
+        // RFC URI checker rejects a recorded URL containing `|` in its query even
+        // though Arena accepted and fetched it successfully.
+        this.ajv.addFormat("uri", {
+            type: "string",
+            validate: (value) => URL.canParse(value),
+        });
         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 handler is wired.
+    // ask_user when no handler is wired. add_voice stays available headlessly.
     availableTools() {
         let definitions = toolDefinitions(this.workspaceContext);
         if (!this.askUserEnabled) {
@@ -477,23 +619,82 @@ class ArenaToolExecutor {
         try {
             // 监听器不会补发已发生的 abort：已取消的 signal 必须在产生任何副作用
             // 之前短路，否则命令会照常 spawn 直到自然结束。
-            this.signal?.throwIfAborted();
+            if (this.signal?.aborted) {
+                return {
+                    role: "tool",
+                    tool_call_id: callId,
+                    content: json({ status: "aborted" }),
+                };
+            }
             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
-                : "{}");
             const validate = this.validators.get(name);
-            if (!validate)
-                throw new Error(`unknown tool: ${name}`);
-            if (!validate(argumentsValue)) {
-                const errors = (validate.errors || [])
-                    .map((error) => `${error.instancePath || "/"} ${error.message}`)
-                    .join("; ");
-                throw new Error(`invalid arguments: ${errors}`);
+            if (!validate) {
+                return {
+                    role: "tool",
+                    tool_call_id: callId,
+                    content: unavailableToolError(name, toolDefinitions(this.workspaceContext).map((definition) => definition.function.name)),
+                };
+            }
+            const argumentsText = typeof call.function?.arguments === "string"
+                ? call.function.arguments
+                : "{}";
+            let argumentsValue;
+            try {
+                argumentsValue = JSON.parse(argumentsText);
+            }
+            catch (error) {
+                return {
+                    role: "tool",
+                    tool_call_id: callId,
+                    content: arenaJsonParsingError(name, argumentsText, error),
+                };
+            }
+            const malformedArguments = argumentsValue !== null &&
+                typeof argumentsValue === "object" &&
+                !Array.isArray(argumentsValue)
+                ? argumentsValue.__malformedToolArguments
+                : undefined;
+            if (typeof malformedArguments === "string") {
+                try {
+                    JSON.parse(malformedArguments);
+                }
+                catch (error) {
+                    return {
+                        role: "tool",
+                        tool_call_id: callId,
+                        content: arenaJsonParsingError(name, malformedArguments, error),
+                    };
+                }
+            }
+            const validatedArguments = structuredClone(argumentsValue);
+            if (!validate(validatedArguments)) {
+                return {
+                    role: "tool",
+                    tool_call_id: callId,
+                    content: arenaValidationError(name, argumentsValue, validate.errors),
+                };
+            }
+            const startedAt = Date.now();
+            let result;
+            try {
+                result = await this.dispatch(name, validatedArguments, callId, context);
+            }
+            catch (error) {
+                if (error instanceof AskUserHandlerError) {
+                    return {
+                        role: "tool",
+                        tool_call_id: callId,
+                        content: json({ status: "error", message: error.message }),
+                    };
+                }
+                return {
+                    role: "tool",
+                    tool_call_id: callId,
+                    content: json(this.runtimeFailureResult(name, validatedArguments, error, startedAt)),
+                };
             }
-            const result = await this.dispatch(name, argumentsValue, callId, context);
             const content = typeof result === "string" ? result : json(result);
             if (content.length > toolResultCharacterLimit) {
                 return {
@@ -514,13 +715,6 @@ class ArenaToolExecutor {
             };
         }
         catch (error) {
-            if (error instanceof AskUserHandlerError) {
-                return {
-                    role: "tool",
-                    tool_call_id: callId,
-                    content: json({ status: "error", message: error.message }),
-                };
-            }
             return {
                 role: "tool",
                 tool_call_id: callId,
@@ -531,6 +725,83 @@ class ArenaToolExecutor {
             };
         }
     }
+    runtimeFailureResult(name, values, error, startedAt) {
+        if (this.signal?.aborted)
+            return { status: "aborted" };
+        const message = errorMessage(error);
+        const durationMs = Date.now() - startedAt;
+        if (name === "bash") {
+            const stderr = this.virtualizeBashOutput(message);
+            return {
+                status: "shell_error",
+                stderr,
+                stdout: "",
+                exit_code: null,
+                duration_ms: durationMs,
+                stderr_truncated: false,
+                stdout_truncated: false,
+            };
+        }
+        if (name === "start_process") {
+            const cwd = String(values.cwd || "/home/user");
+            const code = error?.code;
+            const logTail = code === "ENOENT"
+                ? `[invalid_argument] cwd '${cwd}' does not exist`
+                : message;
+            return {
+                status: "shell_error",
+                process_id: null,
+                pid: null,
+                exit_code: null,
+                log_tail: logTail,
+                listening_ports: [],
+                new_ports: [],
+                duration_ms: durationMs,
+            };
+        }
+        if (name === "get_process_output") {
+            return {
+                status: "shell_error",
+                log_tail: message,
+                exit_code: null,
+                listening_ports: [],
+            };
+        }
+        if (name === "stop_process") {
+            return { status: "shell_error", log_tail: message };
+        }
+        if (name === "fetch_page") {
+            return { status: "error", error: fetchPageFailure(message) };
+        }
+        if (name === "add_voice") {
+            return {
+                status: "error",
+                message: prefixedFailure("Failed to audition voices: ", message),
+            };
+        }
+        if (name === "generate_image") {
+            return {
+                status: "error",
+                message: prefixedFailure("Failed to generate image: ", message),
+            };
+        }
+        if (name === "generate_speech") {
+            return {
+                status: "error",
+                message: prefixedFailure("Failed to generate speech: ", message),
+            };
+        }
+        if (name === "image_search") {
+            return {
+                status: "error",
+                message: prefixedFailure("Image search failed: ", message),
+            };
+        }
+        if (name === "present_file") {
+            return { status: "error", message: "Error calling present file tool" };
+        }
+        return { status: "error", message };
+    }
     takeVisualMessage(toolCallIds) {
         // 生产契约：同一组 tool call 的全部图片汇入一条 user message，
         // 由一个 arena-system-message 文本 part 领头。
@@ -557,6 +828,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 +846,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 +876,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 +930,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 +952,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 +967,6 @@ class ArenaToolExecutor {
             let stderr = "";
             let timedOut = false;
             let settled = false;
-            let killRequested = false;
             let forceSettle;
             const killTree = (signal) => {
                 try {
@@ -692,33 +985,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 +1018,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 +1047,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,9 +1084,77 @@ 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");
+        let target;
+        let source;
+        try {
+            target = await this.confinedPath(rawPath);
+            if (!(await stat(target)).isFile()) {
+                return {
+                    status: "error",
+                    message: `File not found: ${rawPath}`,
+                };
+            }
+            source = await readFile(target, "utf8");
+        }
+        catch {
+            return {
+                status: "error",
+                message: `Failed to read workspace file: ${rawPath}`,
+            };
+        }
         // 仅精确匹配：曾有空白容错回退，但 T1(b) 回放证实生产没有——case-003
         // 四个 old_text 精确缺失的 edit 生产全部返回 Context not found，而回退
         // 会静默改错文件；全部参考成功样本也都能走精确路径复现。
@@ -798,7 +1167,15 @@ class ArenaToolExecutor {
                 message: "Context not found. Read the file to verify the text exists.",
             };
         }
-        await writeFile(target, source.replace(oldText, newText), "utf8");
+        try {
+            await writeFile(target, source.replace(oldText, newText), "utf8");
+        }
+        catch {
+            return {
+                status: "error",
+                message: `Failed to write workspace file: ${rawPath}`,
+            };
+        }
         return { status: "success", message: `Edited ${rawPath}.` };
     }
     async readWorkspaceFile(rawPath, toolCallId) {
@@ -842,6 +1219,15 @@ class ArenaToolExecutor {
         if (kind === "image" && fileSize > 20 * 1024 * 1024) {
             throw new Error(`image exceeds 20 MB: ${rawPath}`);
         }
+        // Current Arena v2 captures consistently expose local PDFs as binary
+        // metadata. PDF text extraction belongs to fetch_page, not read_file.
+        if (extension === ".pdf") {
+            return {
+                kind: "unsupported",
+                mediaType: "application/pdf",
+                size: fileSize,
+            };
+        }
         const mainModelSupportsImages = kind === "image" ? supportsImageInput(this.config) : false;
         const fallbackModel = mainModelSupportsImages
             ? undefined
@@ -939,9 +1325,18 @@ class ArenaToolExecutor {
         };
     }
     async writeWorkspaceFile(rawPath, content) {
-        const target = await this.confinedPath(rawPath);
-        mkdirSync(path.dirname(target), { recursive: true });
-        await writeFile(target, content, "utf8");
+        let target;
+        try {
+            target = await this.confinedPath(rawPath);
+            mkdirSync(path.dirname(target), { recursive: true });
+            await writeFile(target, content, "utf8");
+        }
+        catch {
+            return {
+                status: "error",
+                message: `Failed to write workspace file: ${rawPath}`,
+            };
+        }
         return { status: "success" };
     }
     async webSearch(query, depth) {
@@ -1002,23 +1397,35 @@ class ArenaToolExecutor {
                 }
             }
         }
+        if (!saved.length) {
+            return {
+                status: "error",
+                message: "Image search failed: Strict safe search filtered all results for this query. " +
+                    "Try a different or more specific query.",
+            };
+        }
         return { status: "success", results: saved };
     }
     async presentFile(rawPath) {
-        const target = await this.confinedPath(rawPath);
-        if (!(await stat(target)).isFile())
-            throw new Error(rawPath);
-        return { path: rawPath, status: "success" };
+        try {
+            const target = await this.confinedPath(rawPath);
+            if (!(await stat(target)).isFile())
+                throw new Error(rawPath);
+            return { path: rawPath, status: "success" };
+        }
+        catch {
+            return { status: "error", message: "Error calling present file tool" };
+        }
     }
     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();
@@ -1026,173 +1433,66 @@ class ArenaToolExecutor {
             if (!mimeType?.startsWith("image/")) {
                 throw new Error(`unsupported reference image format: ${imagePath}`);
             }
-            const bytes = await readFile(source);
+            let bytes;
+            try {
+                bytes = await readFile(source);
+            }
+            catch {
+                throw new Error(`Failed to read workspace file: ${imagePath}`);
+            }
             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),