@qwen-code/arena-agent 0.0.1

package/dist/tools.js

@@ -0,0 +1,992 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, realpathSync, } from "node:fs";
+import { 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 { extractStructuredDocument, isStructuredDocument, } from "./document-reader.js";
+import { FetchPageReader } from "./fetch-page.js";
+import { toolDefinitions } from "./spec.js";
+const knownTextApplicationMimeTypes = new Set([
+    "application/ecmascript",
+    "application/javascript",
+    "application/json",
+    "application/node",
+    "application/toml",
+    "application/xml",
+]);
+const knownTextExtensions = new Set([
+    ".adoc",
+    ".astro",
+    ".bash",
+    ".bib",
+    ".c",
+    ".cc",
+    ".cfg",
+    ".clj",
+    ".cmake",
+    ".conf",
+    ".cpp",
+    ".cs",
+    ".css",
+    ".cts",
+    ".cxx",
+    ".dart",
+    ".dockerfile",
+    ".ex",
+    ".exs",
+    ".fish",
+    ".fs",
+    ".go",
+    ".gql",
+    ".gradle",
+    ".graphql",
+    ".groovy",
+    ".h",
+    ".hcl",
+    ".hpp",
+    ".hs",
+    ".html",
+    ".ini",
+    ".java",
+    ".js",
+    ".json",
+    ".jsx",
+    ".kt",
+    ".kts",
+    ".lua",
+    ".m",
+    ".md",
+    ".mjs",
+    ".mk",
+    ".mm",
+    ".mts",
+    ".nim",
+    ".org",
+    ".php",
+    ".pl",
+    ".pm",
+    ".properties",
+    ".proto",
+    ".ps1",
+    ".py",
+    ".pyi",
+    ".r",
+    ".rb",
+    ".rs",
+    ".rst",
+    ".scala",
+    ".sh",
+    ".sol",
+    ".sql",
+    ".svelte",
+    ".svg",
+    ".swift",
+    ".tex",
+    ".tf",
+    ".tfvars",
+    ".toml",
+    ".ts",
+    ".tsx",
+    ".txt",
+    ".vb",
+    ".vue",
+    ".xml",
+    ".yaml",
+    ".yml",
+    ".zig",
+    ".zsh",
+]);
+const knownTextBasenames = new Set([
+    ".bashrc",
+    ".dockerignore",
+    ".editorconfig",
+    ".env",
+    ".gitattributes",
+    ".gitignore",
+    ".npmignore",
+    ".profile",
+    ".zshrc",
+    "AUTHORS",
+    "BUILD",
+    "CHANGELOG",
+    "CMakeLists.txt",
+    "COPYING",
+    "Cargo.lock",
+    "Containerfile",
+    "Dockerfile",
+    "Gemfile",
+    "GNUmakefile",
+    "Jenkinsfile",
+    "LICENSE",
+    "Makefile",
+    "NOTICE",
+    "Pipfile",
+    "Pipfile.lock",
+    "Procfile",
+    "README",
+    "Rakefile",
+    "Vagrantfile",
+    "WORKSPACE",
+    "go.mod",
+    "go.sum",
+    "go.work",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "poetry.lock",
+    "requirements.txt",
+    "yarn.lock",
+]);
+const knownBinaryExtensions = new Set([
+    ".7z",
+    ".a",
+    ".bin",
+    ".bz2",
+    ".class",
+    ".dll",
+    ".doc",
+    ".docx",
+    ".dylib",
+    ".exe",
+    ".flac",
+    ".gz",
+    ".jar",
+    ".o",
+    ".obj",
+    ".odt",
+    ".ods",
+    ".odp",
+    ".pdf",
+    ".ppt",
+    ".pptx",
+    ".rar",
+    ".so",
+    ".tar",
+    ".wasm",
+    ".xls",
+    ".xlsx",
+    ".zip",
+]);
+const visibleImageExtensions = new Set([
+    ".bmp",
+    ".gif",
+    ".jpeg",
+    ".jpg",
+    ".png",
+    ".webp",
+]);
+const imagePlaceholder = "[Image content is provided in the next user message.]";
+const mimeTypes = {
+    ".aac": "audio/aac",
+    ".bmp": "image/bmp",
+    ".gif": "image/gif",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".m4a": "audio/mp4",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4",
+    ".ogg": "audio/ogg",
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".wav": "audio/wav",
+    ".webm": "video/webm",
+    ".webp": "image/webp",
+};
+function detectBom(data) {
+    if (data.length >= 4 &&
+        data[0] === 0xff &&
+        data[1] === 0xfe &&
+        data[2] === 0x00 &&
+        data[3] === 0x00) {
+        return { encoding: "utf32le", length: 4 };
+    }
+    if (data.length >= 4 &&
+        data[0] === 0x00 &&
+        data[1] === 0x00 &&
+        data[2] === 0xfe &&
+        data[3] === 0xff) {
+        return { encoding: "utf32be", length: 4 };
+    }
+    if (data.length >= 3 &&
+        data[0] === 0xef &&
+        data[1] === 0xbb &&
+        data[2] === 0xbf) {
+        return { encoding: "utf8", length: 3 };
+    }
+    if (data.length >= 2 && data[0] === 0xff && data[1] === 0xfe) {
+        return { encoding: "utf16le", length: 2 };
+    }
+    if (data.length >= 2 && data[0] === 0xfe && data[1] === 0xff) {
+        return { encoding: "utf16be", length: 2 };
+    }
+    return undefined;
+}
+function decodeUtf32(data, littleEndian) {
+    const characters = [];
+    const usableLength = data.length - (data.length % 4);
+    for (let index = 0; index < usableLength; index += 4) {
+        const codePoint = littleEndian
+            ? data.readUInt32LE(index)
+            : data.readUInt32BE(index);
+        characters.push(codePoint <= 0x10ffff &&
+            !(codePoint >= 0xd800 && codePoint <= 0xdfff)
+            ? String.fromCodePoint(codePoint)
+            : "\ufffd");
+    }
+    return characters.join("");
+}
+function decodeText(data) {
+    const bom = detectBom(data);
+    if (bom) {
+        const content = data.subarray(bom.length);
+        switch (bom.encoding) {
+            case "utf8":
+                return content.toString("utf8");
+            case "utf16le":
+                return content.toString("utf16le");
+            case "utf16be": {
+                const swapped = Buffer.from(content.subarray(0, content.length - (content.length % 2)));
+                return swapped.swap16().toString("utf16le");
+            }
+            case "utf32le":
+                return decodeUtf32(content, true);
+            case "utf32be":
+                return decodeUtf32(content, false);
+        }
+    }
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(data);
+    }
+    catch {
+        const encoding = detectEncoding(data);
+        if (encoding && iconv.encodingExists(encoding)) {
+            return iconv.decode(data, encoding);
+        }
+        return data.toString("utf8");
+    }
+}
+function isTextMimeType(value) {
+    return (value.startsWith("text/") ||
+        value.endsWith("+json") ||
+        value.endsWith("+xml") ||
+        knownTextApplicationMimeTypes.has(value));
+}
+function sampleLooksBinary(data) {
+    if (data.length === 0 || detectBom(data))
+        return false;
+    let nonPrintable = 0;
+    for (const byte of data) {
+        if (byte === 0)
+            return true;
+        if (byte < 9 || (byte > 13 && byte < 32))
+            nonPrintable += 1;
+    }
+    return nonPrintable / data.length > 0.3;
+}
+function workspaceFileKind(filePath, sample) {
+    const extension = path.extname(filePath).toLowerCase();
+    if (extension === ".svg")
+        return "text";
+    if (visibleImageExtensions.has(extension))
+        return "image";
+    const mimeType = mime.getType(filePath);
+    if (mimeType?.startsWith("image/"))
+        return "image";
+    if (mimeType && isTextMimeType(mimeType))
+        return "text";
+    if (knownBinaryExtensions.has(extension))
+        return "binary";
+    if (knownTextExtensions.has(extension) ||
+        knownTextBasenames.has(path.basename(filePath))) {
+        return "text";
+    }
+    return sampleLooksBinary(sample) ? "binary" : "text";
+}
+function json(value) {
+    return JSON.stringify(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? 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");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function responseBytes(response, limit = 4 * 1024 * 1024) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > limit) {
+        throw new Error(`download exceeds ${limit} bytes`);
+    }
+    return bytes;
+}
+export class ToolExecutor {
+    config;
+    workspace;
+    workspaceReal;
+    validators = new Map();
+    pendingVisualContent = new Map();
+    askUserHandler;
+    signal;
+    workspaceContext;
+    pageReader;
+    ajv = new Ajv({ allErrors: true, strict: false });
+    // ask_user needs an interactive front-end (TUI/WebUI) to collect answers.
+    // Headless `-p` supplies no handler, so the tool is withheld from the model
+    // entirely rather than offered and then dead-ending on needs_input.
+    askUserEnabled;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.workspace = path.resolve(config.workspace);
+        mkdirSync(this.workspace, { recursive: true });
+        this.workspaceReal = realpathSync(this.workspace);
+        this.askUserHandler = options.askUserHandler;
+        this.askUserEnabled = Boolean(options.askUserHandler);
+        this.signal = options.signal;
+        this.workspaceContext = options.workspaceContext;
+        this.pageReader = new FetchPageReader({ 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));
+        }
+    }
+    // The tool schemas offered to the model for this session. Identical to the
+    // canonical trace set, adjusted for the selected workspace runtime and minus
+    // ask_user when no interactive handler is wired.
+    availableTools() {
+        const definitions = toolDefinitions(this.workspaceContext);
+        if (this.askUserEnabled)
+            return definitions;
+        return definitions.filter((definition) => definition.function.name !== "ask_user");
+    }
+    async execute(call) {
+        const callId = String(call.id || "");
+        const name = String(call.function?.name || "");
+        this.pendingVisualContent.delete(callId);
+        try {
+            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}`);
+            }
+            const result = await this.dispatch(name, argumentsValue, callId);
+            return {
+                role: "tool",
+                tool_call_id: callId,
+                content: typeof result === "string" ? result : json(result),
+            };
+        }
+        catch (error) {
+            return {
+                role: "tool",
+                tool_call_id: callId,
+                content: json({
+                    status: "error",
+                    tool: name,
+                    error: errorMessage(error),
+                }),
+            };
+        }
+    }
+    takeVisualMessage(toolCallIds) {
+        const content = [];
+        for (const toolCallId of toolCallIds) {
+            const parts = this.pendingVisualContent.get(toolCallId);
+            this.pendingVisualContent.delete(toolCallId);
+            if (parts)
+                content.push(...parts);
+        }
+        return content.length ? { role: "user", content } : undefined;
+    }
+    async dispatch(name, values, toolCallId) {
+        switch (name) {
+            case "bash":
+                return this.bash(String(values.command), String(values.cwd ||
+                    (this.workspaceContext
+                        ? path.resolve(this.workspaceContext.cwd)
+                        : "/home/user")), Number(values.timeout || 30));
+            case "ask_user":
+                return this.askUser(values.questions, toolCallId);
+            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));
+            case "web_search":
+                return this.webSearch(String(values.query), String(values.depth));
+            case "write_file":
+                return this.writeWorkspaceFile(String(values.path), String(values.content));
+            case "image_search":
+                return this.imageSearch(String(values.query), Number(values.count), toolCallId);
+            case "present_file":
+                return this.presentFile(String(values.path));
+            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);
+            default:
+                throw new Error(`unknown tool: ${name}`);
+        }
+    }
+    async confinedPath(raw) {
+        if (!raw)
+            throw new Error("path must not be empty");
+        let candidate;
+        if (!this.workspaceContext && (raw === "/home/user" || raw === "~")) {
+            candidate = this.workspace;
+        }
+        else if (!this.workspaceContext && raw.startsWith("/home/user/")) {
+            candidate = path.join(this.workspace, raw.slice("/home/user/".length));
+        }
+        else if (!this.workspaceContext && raw.startsWith("~/")) {
+            candidate = path.join(this.workspace, raw.slice(2));
+        }
+        else {
+            const defaultCwd = this.workspaceContext
+                ? path.resolve(this.workspaceContext.cwd)
+                : this.workspace;
+            candidate = path.isAbsolute(raw) ? raw : path.join(defaultCwd, raw);
+        }
+        const absolute = path.resolve(candidate);
+        const lexicalRelative = path.relative(this.workspace, absolute);
+        if (lexicalRelative.startsWith("..") ||
+            path.isAbsolute(lexicalRelative)) {
+            throw new Error(`path is outside the workspace: ${raw}`);
+        }
+        let ancestor = absolute;
+        while (!existsSync(ancestor)) {
+            const parent = path.dirname(ancestor);
+            if (parent === ancestor)
+                break;
+            ancestor = parent;
+        }
+        const ancestorReal = await realpath(ancestor);
+        const resolved = path.resolve(ancestorReal, path.relative(ancestor, absolute));
+        const realRelative = path.relative(this.workspaceReal, resolved);
+        if (realRelative.startsWith("..") || path.isAbsolute(realRelative)) {
+            throw new Error(`path is outside the workspace: ${raw}`);
+        }
+        return resolved;
+    }
+    relativePath(target) {
+        return path.relative(this.workspaceReal, target).split(path.sep).join("/");
+    }
+    async bash(command, cwd, timeoutSeconds) {
+        const workdir = await this.confinedPath(cwd);
+        if (!(await stat(workdir)).isDirectory()) {
+            throw new Error(`cwd is not a directory: ${cwd}`);
+        }
+        return new Promise((resolve, reject) => {
+            const child = spawn("/bin/bash", ["-lc", command], {
+                cwd: workdir,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGKILL");
+            }, timeoutSeconds * 1000);
+            const abort = () => child.kill("SIGTERM");
+            this.signal?.addEventListener("abort", abort, { once: true });
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk.toString("utf8");
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk.toString("utf8");
+            });
+            child.once("error", reject);
+            child.once("close", (code) => {
+                clearTimeout(timeout);
+                this.signal?.removeEventListener("abort", abort);
+                if (this.signal?.aborted) {
+                    reject(this.signal.reason || new Error("operation cancelled"));
+                    return;
+                }
+                if (timedOut) {
+                    resolve({
+                        status: "timeout",
+                        exit_code: null,
+                        stdout: "",
+                        stderr: `command exceeded ${timeoutSeconds}s`,
+                    });
+                    return;
+                }
+                resolve({
+                    status: code === 0 ? "success" : "error",
+                    exit_code: code,
+                    stdout,
+                    stderr,
+                });
+            });
+        });
+    }
+    async askUser(questions, toolCallId) {
+        if (this.askUserHandler) {
+            return this.askUserHandler(toolCallId, questions);
+        }
+        // ask_user is not offered in non-interactive sessions; if the model still
+        // emits it (e.g. resumed history or a hallucinated call), report an error
+        // so the turn continues instead of stalling on needs_input.
+        return {
+            status: "error",
+            tool: "ask_user",
+            error: "ask_user is unavailable in this non-interactive session. " +
+                "Proceed with reasonable defaults and state any assumptions you make.",
+        };
+    }
+    async editFile(rawPath, oldText, newText) {
+        const target = await this.confinedPath(rawPath);
+        const source = await readFile(target, "utf8");
+        let updated;
+        if (source.includes(oldText)) {
+            updated = source.replace(oldText, newText);
+        }
+        else {
+            const tokens = oldText.split(/\s+/).filter(Boolean);
+            const pattern = new RegExp(tokens.map(escapeRegExp).join("\\s+"));
+            if (!pattern.test(source)) {
+                return {
+                    status: "error",
+                    message: "Context not found. Read the file to verify the text exists.",
+                };
+            }
+            updated = source.replace(pattern, newText);
+        }
+        await writeFile(target, updated, "utf8");
+        return { status: "success", message: `Edited ${rawPath}.` };
+    }
+    async readWorkspaceFile(rawPath, toolCallId) {
+        const target = await this.confinedPath(rawPath);
+        const data = await readFile(target);
+        const extension = path.extname(target).toLowerCase();
+        const kind = workspaceFileKind(target, data.subarray(0, 4096));
+        const relativePath = this.relativePath(target);
+        const result = {
+            status: "success",
+            path: relativePath,
+        };
+        if (isStructuredDocument(target)) {
+            const extracted = await extractStructuredDocument(target, data, this.signal);
+            result.content = extracted.content;
+            result.mime_type =
+                mime.getType(target) ||
+                    mimeTypes[extension] ||
+                    "application/octet-stream";
+            result.size = data.length;
+            result.document_type = extracted.documentType;
+            if (extracted.totalPages !== undefined) {
+                result.total_pages = extracted.totalPages;
+                result.pages_parsed = extracted.pagesParsed;
+            }
+            if (extracted.truncated)
+                result.truncated = true;
+            if (extracted.warning)
+                result.warning = extracted.warning;
+        }
+        else if (kind === "text") {
+            result.content = decodeText(data);
+        }
+        else {
+            const mimeType = mime.getType(target) ||
+                mimeTypes[extension] ||
+                "application/octet-stream";
+            result.mime_type = mimeType;
+            result.size = data.length;
+            if (kind === "image") {
+                if (data.length > 20 * 1024 * 1024) {
+                    throw new Error(`image exceeds 20 MB: ${rawPath}`);
+                }
+                result.content = imagePlaceholder;
+                this.pendingVisualContent.set(toolCallId, [
+                    {
+                        text: "<arena-system-message>" +
+                            `The image below is the genuine content returned by read_file for ${JSON.stringify(relativePath)}.` +
+                            "</arena-system-message>",
+                    },
+                    {
+                        image: `data:${mimeType};base64,${data.toString("base64")}`,
+                    },
+                ]);
+            }
+        }
+        return result;
+    }
+    async writeWorkspaceFile(rawPath, content) {
+        const target = await this.confinedPath(rawPath);
+        mkdirSync(path.dirname(target), { recursive: true });
+        await writeFile(target, content, "utf8");
+        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 choices = Array.isArray(output.choices) ? output.choices : [];
+        const answer = stringValue(record(record(choices[0]).message).content);
+        const limit = { "1": 3, "2": 5, "3": 8 }[depth] || 5;
+        return {
+            status: "success",
+            query,
+            answer,
+            results: searchResults.slice(0, limit).map((value, index) => {
+                const item = record(value);
+                return {
+                    id: Number(item.index) || index + 1,
+                    title: stringValue(item.title),
+                    url: stringValue(item.url),
+                    content: stringValue(item.content) ||
+                        stringValue(item.snippet) ||
+                        stringValue(item.summary),
+                    site_name: stringValue(item.site_name),
+                };
+            }),
+        };
+    }
+    async imageSearch(query, count, toolCallId) {
+        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" }],
+            }),
+            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 images = [];
+        const searchId = toolCallId
+            .replace(/[^A-Za-z0-9_-]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .slice(0, 96) || "search";
+        for (const value of results) {
+            if (images.length >= count)
+                break;
+            const item = record(value);
+            const sourceUrl = stringValue(item.url) ||
+                stringValue(item.original_url) ||
+                stringValue(item.image_url) ||
+                stringValue(item.thumbnail_url);
+            if (!sourceUrl)
+                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(`assets/image-search/${searchId}/result-${images.length + 1}${extension}`);
+                mkdirSync(path.dirname(target), { recursive: true });
+                await writeFile(target, await responseBytes(imageResponse));
+                images.push({
+                    path: this.relativePath(target),
+                    source_url: sourceUrl,
+                    title: stringValue(item.title),
+                });
+            }
+            catch (error) {
+                if (this.signal?.aborted)
+                    throw error;
+                // A single inaccessible search result should not fail the whole search.
+            }
+        }
+        return { status: "success", query, images };
+    }
+    async presentFile(rawPath) {
+        const target = await this.confinedPath(rawPath);
+        if (!(await stat(target)).isFile())
+            throw new Error(rawPath);
+        return { path: rawPath, status: "success" };
+    }
+    async generateImage(rawPath, prompt, images) {
+        const target = await this.confinedPath(rawPath);
+        if (![".jpg", ".jpeg", ".png"].includes(path.extname(target).toLowerCase())) {
+            throw new Error("file_path must end in .jpg, .jpeg, or .png");
+        }
+        mkdirSync(path.dirname(target), { recursive: true });
+        const model = process.env.ARENA_IMAGE_MODEL || "wan2.7-image-pro";
+        const content = [];
+        for (const imagePath of images || []) {
+            const source = await this.confinedPath(imagePath);
+            const extension = path.extname(source).toLowerCase();
+            const mimeType = mimeTypes[extension];
+            if (!mimeType?.startsWith("image/")) {
+                throw new Error(`unsupported reference image format: ${imagePath}`);
+            }
+            const bytes = await readFile(source);
+            if (bytes.length > 20 * 1024 * 1024) {
+                throw new Error(`reference image exceeds 20 MB: ${imagePath}`);
+            }
+            content.push({
+                image: `data:${mimeType};base64,${bytes.toString("base64")}`,
+            });
+        }
+        content.push({ text: prompt });
+        const parameters = {
+            size: process.env.ARENA_IMAGE_SIZE || "2K",
+            n: 1,
+            watermark: false,
+        };
+        if (!images?.length)
+            parameters.thinking_mode = true;
+        const submitted = await dashScopeJson("api", "/services/aigc/image-generation/generation", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-dashscope-async": "enable",
+            },
+            body: JSON.stringify({
+                model,
+                input: {
+                    messages: [{ role: "user", content }],
+                },
+                parameters,
+            }),
+            signal: this.signal,
+        }, "generate_image");
+        const taskId = stringValue(record(submitted.output).task_id);
+        if (!taskId) {
+            throw new Error(`generate_image returned no task_id: ${responseMessage(submitted)}`);
+        }
+        const timeoutMs = Number(process.env.DASHSCOPE_TASK_TIMEOUT_MS || 5 * 60 * 1000);
+        const pollIntervalMs = Number(process.env.DASHSCOPE_TASK_POLL_INTERVAL_MS || 1000);
+        const deadline = Date.now() + timeoutMs;
+        let completed;
+        while (Date.now() <= deadline) {
+            const task = await dashScopeJson("api", `/tasks/${encodeURIComponent(taskId)}`, { method: "GET", signal: this.signal }, "generate_image status");
+            const output = record(task.output);
+            const taskStatus = stringValue(output.task_status).toUpperCase();
+            if (taskStatus === "SUCCEEDED") {
+                completed = task;
+                break;
+            }
+            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}`);
+        }
+        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 task succeeded without 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));
+        return {
+            status: "success",
+            file_path: this.relativePath(target),
+            task_id: taskId,
+        };
+    }
+    async generateSpeech(rawPath, text, language, voiceIdentity = {}) {
+        const target = await this.confinedPath(rawPath);
+        const extension = path.extname(target).toLowerCase();
+        const format = {
+            ".mp3": "mp3",
+            ".wav": "wav",
+            ".opus": "opus",
+        }[extension];
+        if (!format) {
+            throw new Error("DashScope speech output supports .mp3, .wav, 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 audioResponse = await fetch(audioUrl, { signal: this.signal });
+        if (!audioResponse.ok) {
+            throw new Error(`audio download failed (${audioResponse.status})`);
+        }
+        await writeFile(target, await responseBytes(audioResponse, 25 * 1024 * 1024));
+        return {
+            status: "success",
+            file_path: this.relativePath(target),
+        };
+    }
+}
+//# sourceMappingURL=tools.js.map