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

package/dist/tools.js

@@ -349,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`;
@@ -384,7 +558,14 @@ class ArenaToolExecutor {
     routifyPageReader;
     processManager;
     voiceRegistry;
-    ajv = new Ajv({ allErrors: true, strict: false });
+    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. add_voice
     // remains available without one and deterministically registers a fallback.
@@ -409,6 +590,13 @@ 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));
         }
@@ -431,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 {
@@ -468,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,
@@ -485,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 领头。
@@ -820,8 +1137,24 @@ class ArenaToolExecutor {
         };
     }
     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，而回退
         // 会静默改错文件；全部参考成功样本也都能走精确路径复现。
@@ -834,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) {
@@ -878,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
@@ -975,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) {
@@ -1038,13 +1397,25 @@ 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);
@@ -1062,7 +1433,13 @@ 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}`);
             }