@byteplus-iga-pages/agent 0.0.0-stage → 1.0.4

package/dist/cjs/419.js

@@ -0,0 +1,854 @@
+"use strict";
+exports.ids = [
+    "419"
+];
+exports.modules = {
+    "../tools/src/registry.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            uU: ()=>createToolRegistry,
+            Y: ()=>getTools,
+            nn: ()=>selectSources
+        });
+        var types = __webpack_require__("../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js");
+        var src_error = __webpack_require__("../sandbox/src/error.ts");
+        const REDACTED = "[redacted]";
+        const MAX_ERROR_MESSAGE_LENGTH = 1000;
+        const SENSITIVE_KEY = /token|auth|password|secret|api[_-]?key|credential/i;
+        const BASE64_KEY = /base64|image/i;
+        const INLINE_SECRET = /\b(token|authorization|password|secret|api[_-]?key|credential|signature)\b["']?\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi;
+        const BEARER_TOKEN = /\bBearer\s+[A-Za-z0-9._~+\/-]+=*/gi;
+        const JWT = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+        const SIGNED_QUERY = /([?&](?:access[_-]?token|api[_-]?key|key|token|signature|credential|auth|password|secret)\s*=)[^&#\s]*/gi;
+        const URL_CREDENTIALS = /([a-z][a-z0-9+.-]*:\/\/)[^@\s/]+@/gi;
+        function success(data, preserveScreenshot = false) {
+            return {
+                status: "success",
+                data: sanitize(data, preserveScreenshot)
+            };
+        }
+        function failure(tool, error) {
+            return {
+                status: "error",
+                error: normalizeError(tool, error)
+            };
+        }
+        function normalizeError(tool, error) {
+            if (error instanceof ToolExecutionError) return {
+                tool,
+                ...error.info
+            };
+            if (error instanceof src_error.ES) return {
+                tool,
+                ...error.toJSON(),
+                message: sanitizeMessage(error.message)
+            };
+            if ((0, src_error.zf)(error)) return {
+                tool,
+                code: "UnknownError",
+                message: "Tool execution was cancelled."
+            };
+            if (error instanceof Error) return {
+                tool,
+                code: "UnknownError",
+                message: sanitizeMessage(error.message) || "Tool execution failed."
+            };
+            return {
+                tool,
+                code: "UnknownError",
+                message: "Tool execution failed."
+            };
+        }
+        function sandboxResponseError(error) {
+            const response = error && "object" == typeof error ? error : {};
+            const raw = response.rawResponse;
+            return upstreamError(response.error, raw?.status ?? responseStatus(response.error), responseMessage(error) ?? "The sandbox operation failed.");
+        }
+        class ToolExecutionError extends Error {
+            constructor(info){
+                super(info.message), this.info = info;
+            }
+        }
+        function checkSandboxBusinessResult(body, operation, status) {
+            if (!body || "object" != typeof body) return;
+            const response = body;
+            const data = response.data && "object" == typeof response.data ? response.data : void 0;
+            let message;
+            if (false === response.success) message = responseMessage(response) ?? "The sandbox operation failed.";
+            else if (operation.startsWith("sandbox.file.") && "string" == typeof data?.error_type) message = responseMessage(data) ?? "The file operation failed.";
+            else if ("sandbox.shell.execCommand" === operation || "sandbox.code.executeCode" === operation) {
+                if ("number" == typeof data?.exit_code && 0 !== data.exit_code) message = `Execution exited with code ${data.exit_code}.`;
+                else if ("string" == typeof data?.status && [
+                    "error",
+                    "failed",
+                    "no_change_timeout",
+                    "hard_timeout",
+                    "terminated"
+                ].includes(data.status)) message = `Execution ended with status ${data.status}.`;
+            }
+            if (void 0 !== message) throw upstreamError(body, status, message);
+        }
+        function upstreamError(upstream, status, message) {
+            const summary = new src_error.ES(sanitizeMessage(message), {
+                status
+            }).toJSON();
+            return new ToolExecutionError({
+                ...summary,
+                ...0 === status ? {
+                    status: 0
+                } : {},
+                ...void 0 !== upstream ? {
+                    upstream: redactErrorDetails(upstream)
+                } : {}
+            });
+        }
+        function responseStatus(value, depth = 0) {
+            if (!value || "object" != typeof value || depth > 3) return;
+            const record = value;
+            if ("number" == typeof record.statusCode) return record.statusCode;
+            return responseStatus(record.content, depth + 1);
+        }
+        function sanitize(value, preserveScreenshot = false) {
+            if (Array.isArray(value)) return value.map((item)=>sanitize(item));
+            if (null !== value && "object" == typeof value) return Object.fromEntries(Object.entries(value).map(([key, item])=>{
+                if (SENSITIVE_KEY.test(key)) return [
+                    key,
+                    REDACTED
+                ];
+                if (preserveScreenshot && "base64Image" === key) return [
+                    key,
+                    item
+                ];
+                if (BASE64_KEY.test(key) && "string" == typeof item) return [
+                    `${key}Length`,
+                    item.length
+                ];
+                return [
+                    key,
+                    sanitize(item)
+                ];
+            }));
+            return value;
+        }
+        function redactText(message) {
+            return message.replace(BEARER_TOKEN, "Bearer [redacted]").replace(JWT, "[redacted]").replace(SIGNED_QUERY, "$1[redacted]").replace(URL_CREDENTIALS, "$1[redacted]@").replace(INLINE_SECRET, "$1=[redacted]");
+        }
+        function sanitizeMessage(message) {
+            const redacted = redactText(message);
+            return redacted.length > MAX_ERROR_MESSAGE_LENGTH ? `${redacted.slice(0, MAX_ERROR_MESSAGE_LENGTH)}…` : redacted;
+        }
+        function redactErrorDetails(value, ancestors = new WeakSet()) {
+            if ("string" == typeof value) return redactText(value);
+            if (null === value || "object" != typeof value) return value;
+            if (ancestors.has(value)) return "[Circular]";
+            ancestors.add(value);
+            try {
+                if (Array.isArray(value)) return value.map((item)=>redactErrorDetails(item, ancestors));
+                return Object.fromEntries(Object.entries(value).filter(([, item])=>"function" != typeof item).map(([key, item])=>[
+                        key,
+                        /token|auth|password|secret|api[_-]?key|credential|signature|cookie/i.test(key) ? REDACTED : redactErrorDetails(item, ancestors)
+                    ]));
+            } finally{
+                ancestors.delete(value);
+            }
+        }
+        function responseMessage(value, depth = 0) {
+            if (!value || "object" != typeof value || depth > 3) return;
+            const record = value;
+            for (const key of [
+                "message",
+                "errorMessage"
+            ])if ("string" == typeof record[key] && record[key].trim()) return record[key];
+            for (const key of [
+                "error",
+                "content",
+                "body"
+            ]){
+                const message = responseMessage(record[key], depth + 1);
+                if (message) return message;
+            }
+        }
+        const shellConsoleEntrySchema = types.Ik({
+            ps1: types.Yj(),
+            command: types.Yj(),
+            output: types.Yj().nullish()
+        });
+        const shellExecSchema = types.Ik({
+            session_id: types.Yj(),
+            command: types.Yj(),
+            status: types.k5([
+                "running",
+                "completed",
+                "no_change_timeout",
+                "hard_timeout",
+                "terminated"
+            ]),
+            output: types.Yj().nullish(),
+            console: types.YO(shellConsoleEntrySchema).nullish(),
+            exit_code: types.ai().nullish()
+        });
+        const filesReadSchema = types.Ik({
+            content: types.Yj(),
+            file: types.Yj()
+        });
+        const filesWriteSchema = types.Ik({
+            file: types.Yj(),
+            bytes_written: types.ai().optional()
+        });
+        const fileListEntrySchema = types.Ik({
+            name: types.Yj(),
+            path: types.Yj(),
+            is_directory: types.zM(),
+            size: types.ai().nullish(),
+            modified_time: types.Yj().nullish(),
+            permissions: types.Yj().nullish(),
+            extension: types.Yj().nullish()
+        });
+        const filesListSchema = types.Ik({
+            path: types.Yj(),
+            files: types.YO(fileListEntrySchema).optional(),
+            total_count: types.ai().optional(),
+            directory_count: types.ai().optional(),
+            file_count: types.ai().optional()
+        });
+        const fileSearchMatchSchema = types.Ik({
+            file: types.Yj(),
+            line_number: types.ai(),
+            line_content: types.Yj(),
+            context_before: types.YO(types.Yj()).nullish(),
+            context_after: types.YO(types.Yj()).nullish()
+        });
+        const filesSearchSchema = types.Ik({
+            path: types.Yj(),
+            pattern: types.Yj(),
+            matches: types.YO(fileSearchMatchSchema).optional(),
+            match_count: types.ai().optional(),
+            files_searched: types.ai().optional(),
+            files_matched: types.ai().optional(),
+            truncated: types.zM().optional()
+        });
+        const filesFindSchema = types.Ik({
+            path: types.Yj(),
+            files: types.YO(types.Yj()).optional()
+        });
+        const codeRunSchema = types.Ik({
+            language: types.k5([
+                "python",
+                "javascript"
+            ]),
+            status: types.Yj(),
+            outputs: types.YO(types.g1(types.L5())).nullable().optional(),
+            code: types.Yj(),
+            stdout: types.Yj().nullable().optional(),
+            stderr: types.Yj().nullable().optional(),
+            exit_code: types.ai().nullable().optional(),
+            traceback: types.YO(types.Yj()).nullable().optional(),
+            session_id: types.Yj().nullable().optional()
+        });
+        const browserNavigationSchema = types.Ik({
+            url: types.Yj().optional(),
+            title: types.Yj().optional(),
+            status: types.ai().optional(),
+            load_time_ms: types.ai().optional()
+        });
+        function parse(schema, value, operation) {
+            const result = schema.safeParse(value);
+            if (result.success) return result.data;
+            const issue = result.error.issues[0];
+            const field = issue?.path.length ? ` at ${issue.path.join(".")}` : "";
+            throw new Error(`${operation} returned invalid result data${field}: ${issue?.message ?? "validation failed"}`);
+        }
+        function mapShellExecOutput(value) {
+            const data = parse(shellExecSchema, value, "sandbox.shell.execCommand");
+            return {
+                sessionId: data.session_id,
+                command: data.command,
+                ...null != data.output ? {
+                    output: data.output
+                } : {},
+                ...null != data.console ? {
+                    console: data.console.map(({ ps1, command, output })=>({
+                            ps1,
+                            command,
+                            ...null != output ? {
+                                output
+                            } : {}
+                        }))
+                } : {},
+                ...null != data.exit_code ? {
+                    exitCode: data.exit_code
+                } : {}
+            };
+        }
+        function mapFilesReadOutput(value) {
+            return parse(filesReadSchema, value, "sandbox.file.readFile");
+        }
+        function mapFilesWriteOutput(value) {
+            const data = parse(filesWriteSchema, value, "sandbox.file.writeFile");
+            return {
+                file: data.file,
+                ...void 0 !== data.bytes_written ? {
+                    bytesWritten: data.bytes_written
+                } : {}
+            };
+        }
+        function mapFilesListOutput(value) {
+            const data = parse(filesListSchema, value, "sandbox.file.listPath");
+            return {
+                path: data.path,
+                ...void 0 !== data.files ? {
+                    files: data.files.map((file)=>({
+                            name: file.name,
+                            path: file.path,
+                            isDirectory: file.is_directory,
+                            ...null != file.size ? {
+                                size: file.size
+                            } : {},
+                            ...null != file.modified_time ? {
+                                modifiedTime: file.modified_time
+                            } : {},
+                            ...null != file.permissions ? {
+                                permissions: file.permissions
+                            } : {},
+                            ...null != file.extension ? {
+                                extension: file.extension
+                            } : {}
+                        }))
+                } : {},
+                ...void 0 !== data.total_count ? {
+                    totalCount: data.total_count
+                } : {},
+                ...void 0 !== data.directory_count ? {
+                    directoryCount: data.directory_count
+                } : {},
+                ...void 0 !== data.file_count ? {
+                    fileCount: data.file_count
+                } : {}
+            };
+        }
+        function mapFilesSearchOutput(value) {
+            const data = parse(filesSearchSchema, value, "sandbox.file.grepFiles");
+            return {
+                path: data.path,
+                pattern: data.pattern,
+                ...void 0 !== data.matches ? {
+                    matches: data.matches.map((match)=>({
+                            file: match.file,
+                            lineNumber: match.line_number,
+                            lineContent: match.line_content,
+                            ...null != match.context_before ? {
+                                contextBefore: match.context_before
+                            } : {},
+                            ...null != match.context_after ? {
+                                contextAfter: match.context_after
+                            } : {}
+                        }))
+                } : {},
+                ...void 0 !== data.match_count ? {
+                    matchCount: data.match_count
+                } : {},
+                ...void 0 !== data.files_searched ? {
+                    filesSearched: data.files_searched
+                } : {},
+                ...void 0 !== data.files_matched ? {
+                    filesMatched: data.files_matched
+                } : {},
+                ...void 0 !== data.truncated ? {
+                    truncated: data.truncated
+                } : {}
+            };
+        }
+        function mapFilesFindOutput(value) {
+            return parse(filesFindSchema, value, "sandbox.file.findFiles");
+        }
+        function mapCodeRunOutput(value) {
+            const data = parse(codeRunSchema, value, "sandbox.code.executeCode");
+            return {
+                language: data.language,
+                ...null != data.outputs ? {
+                    outputs: data.outputs
+                } : {},
+                code: data.code,
+                ...null != data.stdout ? {
+                    stdout: data.stdout
+                } : {},
+                ...null != data.stderr ? {
+                    stderr: data.stderr
+                } : {},
+                ...null != data.exit_code ? {
+                    exitCode: data.exit_code
+                } : {},
+                ...null != data.traceback ? {
+                    traceback: data.traceback
+                } : {},
+                ...null != data.session_id ? {
+                    sessionId: data.session_id
+                } : {}
+            };
+        }
+        function mapBrowserFetchOutput(navigation, content) {
+            const metadata = parse(browserNavigationSchema, navigation ?? {}, "sandbox.browser.navigate");
+            const html = parse(types.Yj(), content, "sandbox.browser.getHtml");
+            return {
+                content: html,
+                ...void 0 !== metadata.url ? {
+                    url: metadata.url
+                } : {},
+                ...void 0 !== metadata.title ? {
+                    title: metadata.title
+                } : {},
+                ...void 0 !== metadata.status ? {
+                    status: metadata.status
+                } : {},
+                ...void 0 !== metadata.load_time_ms ? {
+                    loadTimeMs: metadata.load_time_ms
+                } : {}
+            };
+        }
+        async function mapBrowserScreenshotOutput(body) {
+            const binary = body;
+            if (!binary || "function" != typeof binary.arrayBuffer) throw new Error("Sandbox screenshot did not return image bytes.");
+            const buffer = Buffer.from(await binary.arrayBuffer());
+            let mimeType;
+            if (buffer.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex"))) mimeType = "image/png";
+            else if (buffer.length >= 3 && 0xff === buffer[0] && 0xd8 === buffer[1] && 0xff === buffer[2]) mimeType = "image/jpeg";
+            else if ("RIFF" === buffer.toString("ascii", 0, 4) && "WEBP" === buffer.toString("ascii", 8, 12)) mimeType = "image/webp";
+            else if (/^GIF8[79]a$/.test(buffer.toString("ascii", 0, 6))) mimeType = "image/gif";
+            else throw new Error("Sandbox screenshot returned an empty or unsupported image.");
+            const base64Image = buffer.toString("base64");
+            return {
+                base64Image,
+                mimeType,
+                base64ImageLength: base64Image.length
+            };
+        }
+        const strictObject = (properties, required)=>({
+                type: "object",
+                properties,
+                required,
+                additionalProperties: false
+            });
+        const looseBoolean = types.vk((value)=>{
+            if ("string" == typeof value) {
+                const normalized = value.trim().toLowerCase();
+                if ("true" === normalized) return true;
+                if ("false" === normalized) return false;
+            }
+            return value;
+        }, types.zM());
+        function requestOptions(options) {
+            return options?.abortSignal ? {
+                abortSignal: options.abortSignal
+            } : void 0;
+        }
+        function createSandboxTools(sandbox) {
+            return [
+                {
+                    name: "shell_exec",
+                    domain: "shell",
+                    description: "Execute one shell command in the conversation sandbox. Use it for command-line tasks and inspect the returned command result before continuing.",
+                    inputSchema: strictObject({
+                        command: {
+                            type: "string",
+                            description: "Command to execute"
+                        },
+                        cwd: {
+                            type: "string",
+                            description: "Optional working directory"
+                        },
+                        timeout: {
+                            type: "number",
+                            description: "Optional timeout in seconds"
+                        }
+                    }, [
+                        "command"
+                    ]),
+                    validate: types.Ik({
+                        command: types.Yj().min(1),
+                        cwd: types.Yj().min(1).optional(),
+                        timeout: types.au.number().positive().optional()
+                    }).strict(),
+                    execute: async (input, options)=>{
+                        const response = await sandbox.shell.execCommand({
+                            command: input.command,
+                            exec_dir: input.cwd,
+                            timeout: input.timeout
+                        }, requestOptions(options));
+                        return mapData(response, "sandbox.shell.execCommand", mapShellExecOutput);
+                    }
+                },
+                {
+                    name: "files_read",
+                    domain: "files",
+                    description: "Read a text file from the conversation sandbox. Use a precise path and optional line range; do not use it for binary content.",
+                    inputSchema: strictObject({
+                        path: {
+                            type: "string",
+                            description: "File path"
+                        },
+                        startLine: {
+                            type: "number",
+                            minimum: 1,
+                            description: "Optional 1-based first line; must be a positive integer"
+                        },
+                        endLine: {
+                            type: "number",
+                            minimum: 1,
+                            description: "Optional 1-based last line; must be a positive integer"
+                        }
+                    }, [
+                        "path"
+                    ]),
+                    validate: types.Ik({
+                        path: types.Yj().min(1),
+                        startLine: types.au.number().int().positive().optional(),
+                        endLine: types.au.number().int().positive().optional()
+                    }).strict(),
+                    execute: async (input, options)=>mapData(await sandbox.file.readFile({
+                            file: input.path,
+                            start_line: void 0 === input.startLine ? void 0 : input.startLine - 1,
+                            end_line: input.endLine
+                        }, requestOptions(options)), "sandbox.file.readFile", mapFilesReadOutput)
+                },
+                {
+                    name: "files_write",
+                    domain: "files",
+                    description: "Write complete text content to a file in the conversation sandbox. This may overwrite an existing file.",
+                    inputSchema: strictObject({
+                        path: {
+                            type: "string",
+                            description: "File path"
+                        },
+                        content: {
+                            type: "string",
+                            description: "Complete file content"
+                        },
+                        append: {
+                            type: "boolean",
+                            description: "Append instead of overwrite"
+                        }
+                    }, [
+                        "path",
+                        "content"
+                    ]),
+                    validate: types.Ik({
+                        path: types.Yj().min(1),
+                        content: types.Yj(),
+                        append: looseBoolean.optional()
+                    }).strict(),
+                    execute: async (input, options)=>mapData(await sandbox.file.writeFile({
+                            file: input.path,
+                            content: input.content,
+                            append: input.append
+                        }, requestOptions(options)), "sandbox.file.writeFile", mapFilesWriteOutput)
+                },
+                {
+                    name: "files_list",
+                    domain: "files",
+                    description: "List files and directories under a sandbox path. Use this before reading an unknown directory tree.",
+                    inputSchema: strictObject({
+                        path: {
+                            type: "string",
+                            description: "Directory path"
+                        },
+                        recursive: {
+                            type: "boolean",
+                            description: "Whether to recurse"
+                        }
+                    }, [
+                        "path"
+                    ]),
+                    validate: types.Ik({
+                        path: types.Yj().min(1),
+                        recursive: looseBoolean.optional()
+                    }).strict(),
+                    execute: async (input, options)=>mapData(await sandbox.file.listPath({
+                            path: input.path,
+                            recursive: input.recursive
+                        }, requestOptions(options)), "sandbox.file.listPath", mapFilesListOutput)
+                },
+                {
+                    name: "files_search",
+                    domain: "files",
+                    description: "Search file contents in the sandbox using a text or regular-expression pattern. Prefer this to reading every file.",
+                    inputSchema: strictObject({
+                        path: {
+                            type: "string",
+                            description: "Search root path"
+                        },
+                        pattern: {
+                            type: "string",
+                            description: "Content pattern"
+                        },
+                        maxResults: {
+                            type: "number",
+                            description: "Maximum matches"
+                        }
+                    }, [
+                        "path",
+                        "pattern"
+                    ]),
+                    validate: types.Ik({
+                        path: types.Yj().min(1),
+                        pattern: types.Yj().min(1),
+                        maxResults: types.au.number().int().positive().optional()
+                    }).strict(),
+                    execute: async (input, options)=>mapData(await sandbox.file.grepFiles({
+                            path: input.path,
+                            pattern: input.pattern,
+                            max_results: input.maxResults
+                        }, requestOptions(options)), "sandbox.file.grepFiles", mapFilesSearchOutput)
+                },
+                {
+                    name: "files_find",
+                    domain: "files",
+                    description: "Find sandbox files by glob pattern. Use it to discover files by name without searching their contents.",
+                    inputSchema: strictObject({
+                        path: {
+                            type: "string",
+                            description: "Search root path"
+                        },
+                        glob: {
+                            type: "string",
+                            description: "Glob pattern"
+                        }
+                    }, [
+                        "path",
+                        "glob"
+                    ]),
+                    validate: types.Ik({
+                        path: types.Yj().min(1),
+                        glob: types.Yj().min(1)
+                    }).strict(),
+                    execute: async (input, options)=>mapData(await sandbox.file.findFiles({
+                            path: input.path,
+                            glob: input.glob
+                        }, requestOptions(options)), "sandbox.file.findFiles", mapFilesFindOutput)
+                },
+                {
+                    name: "code_run",
+                    domain: "code",
+                    description: "Execute a short JavaScript or Python program in the sandbox. Use shell_exec when command-line behavior is required.",
+                    inputSchema: strictObject({
+                        language: {
+                            type: "string",
+                            enum: [
+                                "python",
+                                "javascript"
+                            ],
+                            description: "Execution language"
+                        },
+                        code: {
+                            type: "string",
+                            description: "Source code"
+                        },
+                        timeout: {
+                            type: "number",
+                            description: "Optional timeout in seconds"
+                        }
+                    }, [
+                        "language",
+                        "code"
+                    ]),
+                    validate: types.Ik({
+                        language: types.k5([
+                            "python",
+                            "javascript"
+                        ]),
+                        code: types.Yj().min(1),
+                        timeout: types.au.number().positive().optional()
+                    }).strict(),
+                    execute: async (input, options)=>mapData(await sandbox.code.executeCode({
+                            language: input.language,
+                            code: input.code,
+                            timeout: input.timeout
+                        }, requestOptions(options)), "sandbox.code.executeCode", mapCodeRunOutput)
+                },
+                {
+                    name: "browser_fetch",
+                    domain: "browser",
+                    description: "Navigate the sandbox browser to a URL and inspect the DOM content at that URL. Use this for web content that needs browser rendering. Output semantics: returns page metadata (url, title, status) plus the page HTML document returned by the sandbox, without truncation. Navigation or content failures return status:error with an error summary and the upstream business response in error.upstream. Side effects: navigation changes the current sandbox browser page. Common mistakes: do not use browser_fetch for general web search or information discovery.",
+                    inputSchema: strictObject({
+                        url: {
+                            type: "string",
+                            description: "Absolute URL"
+                        }
+                    }, [
+                        "url"
+                    ]),
+                    validate: types.Ik({
+                        url: types.Yj().url()
+                    }).strict(),
+                    execute: async (input, options)=>{
+                        const opts = requestOptions(options);
+                        const browser = sandbox.browserPage;
+                        const navigation = unwrapDict(await browser.navigate({
+                            url: input.url
+                        }, opts), "sandbox.browser.navigate");
+                        const html = unwrapDict(await browser.getHtml({}, opts), "sandbox.browser.getHtml");
+                        return mapBrowserFetchOutput(navigation.data, html.data);
+                    }
+                },
+                {
+                    name: "browser_screenshot",
+                    domain: "browser",
+                    description: "Capture a screenshot of the current sandbox browser page. Returns the image content with its MIME type and Base64 length. Framework adapters send it as an image to vision-capable models; it is not a file path. Use browser_fetch for page text and browser_fetch before this tool to navigate to the target page first.",
+                    inputSchema: strictObject({
+                        fullPage: {
+                            type: "boolean",
+                            description: "Capture the full page"
+                        }
+                    }, []),
+                    validate: types.Ik({
+                        fullPage: looseBoolean.optional()
+                    }).strict(),
+                    execute: async (input, options)=>{
+                        const response = await sandbox.browserPage.screenshot({
+                            full_page: input.fullPage
+                        }, requestOptions(options));
+                        if (!response.ok) return unwrap(response, "sandbox.browser.screenshot");
+                        return mapBrowserScreenshotOutput(response.body);
+                    }
+                }
+            ];
+        }
+        function bindSandboxTool(spec) {
+            const schema = spec.validate.extend(Object.fromEntries(Object.entries(spec.validate.shape).map(([name, field])=>{
+                const property = spec.inputSchema.properties[name];
+                const validator = field;
+                return [
+                    name,
+                    property?.description === void 0 ? validator : validator.describe(property.description)
+                ];
+            })));
+            return {
+                schema,
+                definition: {
+                    name: spec.name,
+                    description: spec.description,
+                    inputSchema: spec.inputSchema,
+                    async execute (input, options) {
+                        const parsed = schema.safeParse(input);
+                        if (!parsed.success) return {
+                            status: "error",
+                            error: {
+                                tool: spec.name,
+                                code: "UnknownError",
+                                message: sanitizeMessage(parsed.error.issues[0]?.message ?? "The tool input is invalid."),
+                                issues: redactErrorDetails(parsed.error.issues)
+                            }
+                        };
+                        try {
+                            return success(await spec.execute(parsed.data, options), "browser_screenshot" === spec.name);
+                        } catch (error) {
+                            return failure(spec.name, error);
+                        }
+                    }
+                }
+            };
+        }
+        function unwrap(response, operation) {
+            if (response.ok) {
+                checkSandboxBusinessResult(response.body, operation, response.rawResponse?.status);
+                return response.body;
+            }
+            throw sandboxResponseError(response);
+        }
+        function mapData(response, operation, mapper) {
+            const body = unwrap(response, operation);
+            if (!body || "object" != typeof body || !("data" in body) || void 0 === body.data || null === body.data) throw new Error(`${operation} returned no result data.`);
+            return mapper(body.data);
+        }
+        function unwrapDict(response, operation) {
+            const body = unwrap(response, operation);
+            if (null !== body && "object" == typeof body && !Array.isArray(body)) return body;
+            return {};
+        }
+        const DOMAINS = {
+            files: "files",
+            shell: "shell",
+            code: "code",
+            browser: "browser"
+        };
+        function getTools(sandbox) {
+            return createToolRegistry(sandbox, (sources)=>sources.map((source)=>source.definition));
+        }
+        function createToolRegistry(sandbox, adapt, extend) {
+            const sources = createSandboxTools(sandbox).map(bindSandboxTool);
+            const definitions = sources.map((source)=>source.definition);
+            const adapted = adapt(sources);
+            const get = (name)=>{
+                const index = definitions.findIndex((candidate)=>candidate.name === name);
+                if (index < 0) getDefinition(definitions, name);
+                return adapted[index];
+            };
+            const methods = {
+                all: ()=>[
+                        ...adapted
+                    ],
+                get,
+                files: ()=>byDomain(definitions, adapted, DOMAINS.files),
+                shell: ()=>byDomain(definitions, adapted, DOMAINS.shell),
+                code: ()=>byDomain(definitions, adapted, DOMAINS.code),
+                browser: ()=>byDomain(definitions, adapted, DOMAINS.browser),
+                definitions: (names)=>selectDefinitions(definitions, names),
+                ...extend?.(sources, adapted)
+            };
+            return new Proxy(methods, {
+                get (target, property, receiver) {
+                    if ("then" === property) return;
+                    if ("symbol" == typeof property) return Reflect.get(target, property, receiver);
+                    if (property in target) return Reflect.get(target, property, target);
+                    return get(property);
+                }
+            });
+        }
+        function byDomain(definitions, adapted, domain) {
+            const names = DOMAIN_TOOL_NAMES[domain];
+            return definitions.flatMap((tool, index)=>names.has(tool.name) ? [
+                    adapted[index]
+                ] : []);
+        }
+        const DOMAIN_TOOL_NAMES = {
+            shell: new Set([
+                "shell_exec"
+            ]),
+            files: new Set([
+                "files_read",
+                "files_write",
+                "files_list",
+                "files_search",
+                "files_find"
+            ]),
+            code: new Set([
+                "code_run"
+            ]),
+            browser: new Set([
+                "browser_fetch",
+                "browser_screenshot"
+            ])
+        };
+        function selectDefinitions(definitions, names) {
+            if (!names) return [
+                ...definitions
+            ];
+            return names.map((name)=>getDefinition(definitions, name));
+        }
+        function selectSources(sources, names) {
+            if (!names) return [
+                ...sources
+            ];
+            return names.map((name)=>{
+                const source = sources.find((candidate)=>candidate.definition.name === name);
+                if (source) return source;
+                getDefinition(sources.map((candidate)=>candidate.definition), name);
+                throw new Error("Unreachable: unknown tool lookup must throw");
+            });
+        }
+        function getDefinition(definitions, name) {
+            const tool = definitions.find((candidate)=>candidate.name === name);
+            if (tool) return tool;
+            const available = definitions.map((candidate)=>candidate.name).join(", ");
+            throw new Error(`Unknown tool "${name}". Available tools: ${available}`);
+        }
+    }
+};