@xalia/agent 0.6.8 → 0.6.10

package/dist/agent/src/agent/tools/contentExtractors/pdfToText.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pdfToText = pdfToText;
+/**
+ * Extract text string from a text content item if it has one.
+ */
+function getTextStr(item) {
+    if (typeof item === "object" && item !== null && "str" in item) {
+        const str = item.str;
+        return typeof str === "string" ? str : undefined;
+    }
+    return undefined;
+}
+/**
+ * Extract text content from a PDF buffer.
+ *
+ * @param data - PDF file as ArrayBuffer
+ * @param maxLength - Optional maximum length of extracted text
+ * @returns Extracted text content
+ */
+async function pdfToText(data, maxLength) {
+    // Dynamic import required for ESM module in CommonJS project
+    const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+    // Disable worker for Node.js environment
+    const loadingTask = pdfjs.getDocument({
+        data,
+        useWorkerFetch: false,
+        isEvalSupported: false,
+        useSystemFonts: true,
+    });
+    const doc = await loadingTask.promise;
+    let fullText = "";
+    for (let i = 1; i <= doc.numPages; i++) {
+        const page = await doc.getPage(i);
+        const content = await page.getTextContent();
+        const strings = [];
+        for (const item of content.items) {
+            const str = getTextStr(item);
+            if (str !== undefined) {
+                strings.push(str);
+            }
+        }
+        fullText += strings.join(" ") + "\n";
+        page.cleanup();
+        // Early exit if we've exceeded maxLength
+        if (maxLength && fullText.length > maxLength) {
+            break;
+        }
+    }
+    // Apply truncation
+    if (maxLength && fullText.length > maxLength) {
+        return fullText.slice(0, maxLength) + "... [content truncated]";
+    }
+    return fullText.trim();
+}

package/dist/agent/src/agent/tools/datetimeTool.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isoWithTimezone = isoWithTimezone;
+exports.datetimeTool = datetimeTool;
+const DATETIME_DESC = {
+    type: "function",
+    function: {
+        name: "time_now",
+        description: "Current time",
+    },
+};
+function isoWithTimezone(timeZone) {
+    return (new Intl.DateTimeFormat("sv-SE", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+        timeZoneName: "short",
+    })
+        .format(new Date())
+        .replace(" ", "T") + ` (${timeZone})`);
+}
+function datetimeTool(timezone) {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    const toolFn = async () => {
+        return { response: isoWithTimezone(timezone) };
+    };
+    return {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        setup: async (agent) => {
+            agent.addAgentTool(DATETIME_DESC, toolFn);
+        },
+    };
+}

package/dist/agent/src/agent/tools/fileManager/fileManagerTool.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileManagerTool = fileManagerTool;
+const utils_1 = require("../utils");
+const types_1 = require("./types");
+const GET_FILE_CONTENT_TOOL = {
+    type: "function",
+    function: {
+        name: "get_file_content",
+        description: "Get raw file content as data-url. Use this for images or when you " +
+            "need the original binary data. For PDFs and documents where you need " +
+            "the text content, use get_file_parsed_content instead.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "File name",
+                },
+            },
+            required: ["name"],
+        },
+    },
+};
+const PUT_FILE_CONTENT_TOOL = {
+    type: "function",
+    function: {
+        name: "put_file_content",
+        description: "Create or update file content",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "File name",
+                },
+                summary: {
+                    type: "string",
+                    description: "Content summary",
+                },
+                data_url: {
+                    type: "string",
+                    description: "Content data-url: `data:<mime-type>[;<format>],<encoding>`",
+                },
+            },
+            required: ["name", "summary", "data_url"],
+        },
+    },
+};
+const DELETE_FILE_CONTENT_TOOL = {
+    type: "function",
+    function: {
+        name: "delete_file_content",
+        description: "Delete file",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "File name",
+                },
+            },
+            required: ["name"],
+        },
+    },
+};
+const GET_FILE_PARSED_CONTENT_TOOL = {
+    type: "function",
+    function: {
+        name: "get_file_parsed_content",
+        description: "Get extracted text content from a file (e.g., PDF). " +
+            "Returns the parsed text if available, or an error if the file " +
+            "has no parsed content.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "File name",
+                },
+            },
+            required: ["name"],
+        },
+    },
+};
+function fileManagerTool(fileManager) {
+    // `get_file_content` tool
+    //
+    // LLM can read data from the file.  To keep the context small, we overwrite
+    // the data with the session file url after the LLM has seen it.
+    const parseName = (0, utils_1.makeParseArgsFn)(["name"]);
+    const getFileContentFn = async (_agent, args) => {
+        const { name } = parseName(args);
+        const response = await fileManager.getFileContent(name);
+        const overwriteResponse = fileManager.getSessionFileRelativeUrl(name);
+        return { response, overwriteResponse };
+    };
+    // `set_file_content` tool
+    //
+    // Allows LLM to write data (as a data-url) to the session file manager. The
+    // data is replaced by a session file url after being saved.
+    const putArgs = ["name", "summary", "data_url"];
+    const parseNameSummaryDataUrl = (0, utils_1.makeParseArgsFn)(putArgs);
+    const putFileContentFn = async (_, args) => {
+        const parsed = parseNameSummaryDataUrl(args);
+        const { name, summary, data_url } = parsed;
+        const existingFile = fileManager.listFiles().find((f) => f.name === name);
+        const desc = await fileManager.putFileContent(name, summary, data_url);
+        const mimeType = (0, types_1.getSessionFileMimeTypeFromDataUrl)(data_url);
+        // Calculate content size for response message
+        const contentSize = data_url.split(",")[1]?.length || 0;
+        const sizeKB = (contentSize / 1024).toFixed(1);
+        parsed.data_url = fileManager.getSessionFileRelativeUrl(name);
+        const action = existingFile ? "updated" : "created";
+        const responseMsg = `Successfully ${action} file '${desc.name}' with ${sizeKB}KB of content`;
+        return {
+            response: responseMsg,
+            overwriteArgs: JSON.stringify(parsed),
+            _meta: {
+                "xalia/fileUri": parsed.data_url,
+                "xalia/fileMimeType": mimeType,
+            },
+        };
+    };
+    // `delete_file_content` tool
+    //
+    // Allows LLM to write data (as a data-url) to the session file manager. The
+    // data is replaced by a session file url after being saved.
+    const deleteFileFn = async (_, args) => {
+        const { name } = parseName(args);
+        await fileManager.deleteFile(name);
+        return { response: "" };
+    };
+    // `get_file_parsed_content` tool
+    //
+    // Returns extracted text content from files like PDFs.
+    const getFileParsedContentFn = async (_, args) => {
+        const { name } = parseName(args);
+        const parsedContent = await fileManager.getFileParsedContent(name);
+        if (!parsedContent) {
+            return { response: `File '${name}' has no parsed content available.` };
+        }
+        return { response: parsedContent.text };
+    };
+    return {
+        setup: (agent) => {
+            agent.addAgentTool(GET_FILE_CONTENT_TOOL, getFileContentFn);
+            agent.addAgentTool(PUT_FILE_CONTENT_TOOL, putFileContentFn);
+            agent.addAgentTool(DELETE_FILE_CONTENT_TOOL, deleteFileFn);
+            agent.addAgentTool(GET_FILE_PARSED_CONTENT_TOOL, getFileParsedContentFn);
+            return new Promise((r) => {
+                r();
+            });
+        },
+    };
+}

package/dist/agent/src/agent/tools/fileManager/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionFilesManagerPrompt = exports.fileManagerTool = exports.MemoryFileManager = exports.createSessionFileDataUrl = exports.getSessionFileMimeTypeFromDataUrl = exports.isParsedContent = exports.isFileMetaData = exports.EXTENSION_TO_SESSION_FILE_MIME_TYPE = exports.isSessionFileTextMimeType = exports.SESSION_FILE_TEXT_MIME_TYPES = exports.isSessionFileMimeType = exports.SESSION_FILE_MIME_TYPES = exports.createDataUrlFromText = exports.createDataUrlFromBuffer = exports.getMimeTypeFromDataUrl = exports.EXTENSION_TO_IMAGE_MIME_TYPE = exports.isImageMimeType = exports.IMAGE_MIME_TYPES = void 0;
+// Mime types - values
+var mimeTypes_1 = require("./mimeTypes");
+Object.defineProperty(exports, "IMAGE_MIME_TYPES", { enumerable: true, get: function () { return mimeTypes_1.IMAGE_MIME_TYPES; } });
+Object.defineProperty(exports, "isImageMimeType", { enumerable: true, get: function () { return mimeTypes_1.isImageMimeType; } });
+Object.defineProperty(exports, "EXTENSION_TO_IMAGE_MIME_TYPE", { enumerable: true, get: function () { return mimeTypes_1.EXTENSION_TO_IMAGE_MIME_TYPE; } });
+Object.defineProperty(exports, "getMimeTypeFromDataUrl", { enumerable: true, get: function () { return mimeTypes_1.getMimeTypeFromDataUrl; } });
+Object.defineProperty(exports, "createDataUrlFromBuffer", { enumerable: true, get: function () { return mimeTypes_1.createDataUrlFromBuffer; } });
+Object.defineProperty(exports, "createDataUrlFromText", { enumerable: true, get: function () { return mimeTypes_1.createDataUrlFromText; } });
+// Session file types - values
+var types_1 = require("./types");
+Object.defineProperty(exports, "SESSION_FILE_MIME_TYPES", { enumerable: true, get: function () { return types_1.SESSION_FILE_MIME_TYPES; } });
+Object.defineProperty(exports, "isSessionFileMimeType", { enumerable: true, get: function () { return types_1.isSessionFileMimeType; } });
+Object.defineProperty(exports, "SESSION_FILE_TEXT_MIME_TYPES", { enumerable: true, get: function () { return types_1.SESSION_FILE_TEXT_MIME_TYPES; } });
+Object.defineProperty(exports, "isSessionFileTextMimeType", { enumerable: true, get: function () { return types_1.isSessionFileTextMimeType; } });
+Object.defineProperty(exports, "EXTENSION_TO_SESSION_FILE_MIME_TYPE", { enumerable: true, get: function () { return types_1.EXTENSION_TO_SESSION_FILE_MIME_TYPE; } });
+Object.defineProperty(exports, "isFileMetaData", { enumerable: true, get: function () { return types_1.isFileMetaData; } });
+Object.defineProperty(exports, "isParsedContent", { enumerable: true, get: function () { return types_1.isParsedContent; } });
+Object.defineProperty(exports, "getSessionFileMimeTypeFromDataUrl", { enumerable: true, get: function () { return types_1.getSessionFileMimeTypeFromDataUrl; } });
+Object.defineProperty(exports, "createSessionFileDataUrl", { enumerable: true, get: function () { return types_1.createSessionFileDataUrl; } });
+// Implementations
+var memoryFileManager_1 = require("./memoryFileManager");
+Object.defineProperty(exports, "MemoryFileManager", { enumerable: true, get: function () { return memoryFileManager_1.MemoryFileManager; } });
+// Tool - values
+var fileManagerTool_1 = require("./fileManagerTool");
+Object.defineProperty(exports, "fileManagerTool", { enumerable: true, get: function () { return fileManagerTool_1.fileManagerTool; } });
+// Prompt
+var prompt_1 = require("./prompt");
+Object.defineProperty(exports, "createSessionFilesManagerPrompt", { enumerable: true, get: function () { return prompt_1.createSessionFilesManagerPrompt; } });

package/dist/agent/src/agent/tools/fileManager/memoryFileManager.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryFileManager = void 0;
+const uuid_1 = require("uuid");
+const types_1 = require("./types");
+function isSingleLine(str) {
+    return !/[\r\n]/.test(str);
+}
+/**
+ * In-memory implementation of ISessionFileManager
+ */
+class MemoryFileManager {
+    constructor() {
+        this.files = new Map();
+        this.eventHandlers = [];
+    }
+    // ISessionFileManager.listFiles
+    listFiles() {
+        return Array.from(this.files.values());
+    }
+    // ISessionFileManager.getFileContent
+    getFileContent(name) {
+        return new Promise((r, e) => {
+            const entry = this.files.get(name);
+            if (entry) {
+                r(entry.data_url);
+            }
+            else {
+                e(new Error(`no such file ${name}`));
+            }
+        });
+    }
+    // ISessionFileManager.getFileParsedContent
+    getFileParsedContent(name) {
+        return new Promise((r, e) => {
+            const entry = this.files.get(name);
+            if (entry) {
+                r(entry.parsed_content);
+            }
+            else {
+                e(new Error(`no such file ${name}`));
+            }
+        });
+    }
+    // ISessionFileManager.deleteFile
+    deleteFile(name) {
+        return new Promise((r, e) => {
+            if (this.files.has(name)) {
+                this.files.delete(name);
+                this.eventHandlers.forEach((eh) => {
+                    eh.onFileDeleted(name);
+                });
+                r();
+            }
+            else {
+                e(new Error(`no such file ${name}`));
+            }
+        });
+    }
+    // ISessionFileManager.addFile
+    putFileContent(name, summary, data_url, parsed_content) {
+        return new Promise((r, e) => {
+            if (!name) {
+                name = (0, uuid_1.v4)();
+            }
+            if (!summary) {
+                summary = "";
+            }
+            if (!isSingleLine(summary)) {
+                e(new Error("summary must no contain new-lines"));
+            }
+            else {
+                const mime_type = (0, types_1.getSessionFileMimeTypeFromDataUrl)(data_url);
+                const is_new = !this.files.has(name);
+                const entry = {
+                    name,
+                    mime_type,
+                    summary,
+                    parsed_content,
+                    data_url,
+                };
+                this.eventHandlers.forEach((eh) => {
+                    eh.onFileChanged(entry, is_new);
+                });
+                this.files.set(name, entry);
+                r({ name, mime_type, summary, parsed_content });
+            }
+        });
+    }
+    // ISessionFileManager.setEventHandler
+    addEventHandler(eventHandler) {
+        this.eventHandlers.push(eventHandler);
+    }
+    getSessionFileRelativeUrl(name) {
+        return `file+session:/./${name}`;
+    }
+    getSessionFileAbsoluteUrl(name) {
+        // MemoryFileManager doesn't have a session ID, use relative URL
+        return this.getSessionFileRelativeUrl(name);
+    }
+}
+exports.MemoryFileManager = MemoryFileManager;

package/dist/agent/src/{chat/data → agent/tools/fileManager}/mimeTypes.js

@@ -40,5 +40,7 @@ function createDataUrlFromBuffer(data, mime_type) {
     return `data:${mime_type};base64,${imgB64}`;
 }
 function createDataUrlFromText(data, mime_type) {
-    return `data:${mime_type},${data}`;
+    // Properly URL-encode the content to handle special characters
+    const encodedData = encodeURIComponent(data);
+    return `data:${mime_type};charset=utf-8,${encodedData}`;
 }

package/dist/agent/src/agent/tools/fileManager/prompt.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionFilesManagerPrompt = createSessionFilesManagerPrompt;
+/**
+ * Return the file list in a form easily parsable by the LLM.
+ */
+function createSessionFilesManagerPrompt(fm) {
+    const files = fm.listFiles();
+    let prompt = "Files can be read/written as required. Create new files " +
+        "conservatively, usually when complex content is requested. " +
+        "\n\nDATA URL FORMAT: For text files (plain, markdown, html), use " +
+        "URL-encoded format: 'data:<mime-type>;charset=utf-8," +
+        "<URL-encoded-content>'. For binary files (images, PDF), use " +
+        "base64: 'data:<mime-type>;base64,<base64-data>'. URL encoding " +
+        "means using encodeURIComponent() or percent-encoding where " +
+        "special characters become %XX codes." +
+        "\n\n⚠️ CRITICAL: After you call put_file_content, the system " +
+        "AUTOMATICALLY replaces your data_url argument with " +
+        "'file+session://...' in the conversation history. This is NORMAL " +
+        "behavior to save context space. The replacement happens AFTER the " +
+        "file is successfully written. When you see 'file+session://...' in " +
+        "your previous tool call, this means SUCCESS - the file was created " +
+        "with your full content. NEVER retry or attempt to 'fix' this. The " +
+        "file+session:// reference is NOT an error - it confirms the " +
+        "operation succeeded.";
+    if (files.length > 0) {
+        prompt += "\n\nAvailable files:\nname,type,summary\n";
+        for (const f of files) {
+            prompt += `${f.name},${f.mime_type},${f.summary || ""}\n`;
+        }
+    }
+    return prompt;
+}

package/dist/agent/src/{chat/data/dbSessionFileModels.js → agent/tools/fileManager/types.js}

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EXTENSION_TO_SESSION_FILE_MIME_TYPE = exports.SESSION_FILE_TEXT_MIME_TYPES = exports.SESSION_FILE_MIME_TYPES = void 0;
 exports.isSessionFileMimeType = isSessionFileMimeType;
 exports.isSessionFileTextMimeType = isSessionFileTextMimeType;
+exports.isParsedContent = isParsedContent;
 exports.isFileMetaData = isFileMetaData;
 exports.getSessionFileMimeTypeFromDataUrl = getSessionFileMimeTypeFromDataUrl;
 exports.createSessionFileDataUrl = createSessionFileDataUrl;
@@ -34,6 +35,12 @@ exports.EXTENSION_TO_SESSION_FILE_MIME_TYPE = {
     txt: "text/plain",
     md: "text/markdown",
 };
+function isParsedContent(obj) {
+    if (typeof obj !== "object" || obj === null)
+        return false;
+    const pc = obj;
+    return pc.version === 1 && typeof pc.text === "string";
+}
 // Checks that the array of keys matches FileMetaData
 const fileMetaKeys = [
     "xalia/fileUri",

package/dist/agent/src/agent/tools/index.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * General-purpose agent tools.
+ *
+ * These tools are available to all agents, not just chat-based ones.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlToText = exports.webSearch = exports.makeParseArgsFn = exports.renderTool = exports.openURL = exports.openURLTool = exports.webSearchTool = exports.calculatorEval = exports.calculatorTool = exports.isoWithTimezone = exports.datetimeTool = void 0;
+exports.addDefaultTools = addDefaultTools;
+// Tool implementations
+var datetimeTool_1 = require("./datetimeTool");
+Object.defineProperty(exports, "datetimeTool", { enumerable: true, get: function () { return datetimeTool_1.datetimeTool; } });
+Object.defineProperty(exports, "isoWithTimezone", { enumerable: true, get: function () { return datetimeTool_1.isoWithTimezone; } });
+var calculatorTool_1 = require("./calculatorTool");
+Object.defineProperty(exports, "calculatorTool", { enumerable: true, get: function () { return calculatorTool_1.calculatorTool; } });
+Object.defineProperty(exports, "calculatorEval", { enumerable: true, get: function () { return calculatorTool_1.calculatorEval; } });
+var webSearchTool_1 = require("./webSearchTool");
+Object.defineProperty(exports, "webSearchTool", { enumerable: true, get: function () { return webSearchTool_1.webSearchTool; } });
+var openUrlTool_1 = require("./openUrlTool");
+Object.defineProperty(exports, "openURLTool", { enumerable: true, get: function () { return openUrlTool_1.openURLTool; } });
+Object.defineProperty(exports, "openURL", { enumerable: true, get: function () { return openUrlTool_1.openURL; } });
+var renderTool_1 = require("./renderTool");
+Object.defineProperty(exports, "renderTool", { enumerable: true, get: function () { return renderTool_1.renderTool; } });
+// Utilities
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "makeParseArgsFn", { enumerable: true, get: function () { return utils_1.makeParseArgsFn; } });
+var webSearch_1 = require("./webSearch");
+Object.defineProperty(exports, "webSearch", { enumerable: true, get: function () { return webSearch_1.webSearch; } });
+var htmlToText_1 = require("./contentExtractors/htmlToText");
+Object.defineProperty(exports, "htmlToText", { enumerable: true, get: function () { return htmlToText_1.htmlToText; } });
+// File manager (re-export everything)
+__exportStar(require("./fileManager"), exports);
+// Import tools for addDefaultTools
+const datetimeTool_2 = require("./datetimeTool");
+const calculatorTool_2 = require("./calculatorTool");
+const webSearchTool_2 = require("./webSearchTool");
+const openUrlTool_2 = require("./openUrlTool");
+const renderTool_2 = require("./renderTool");
+const fileManager_1 = require("./fileManager");
+/**
+ * Add the default set of general-purpose agent tools.
+ */
+async function addDefaultTools(agent, timezone, _platform, fileManager) {
+    await agent.addAgentToolProvider((0, datetimeTool_2.datetimeTool)(timezone));
+    await agent.addAgentToolProvider(calculatorTool_2.calculatorTool);
+    await agent.addAgentToolProvider((0, renderTool_2.renderTool)(fileManager));
+    await agent.addAgentToolProvider((0, webSearchTool_2.webSearchTool)());
+    await agent.addAgentToolProvider((0, openUrlTool_2.openURLTool)());
+    await agent.addAgentToolProvider((0, fileManager_1.fileManagerTool)(fileManager));
+}

package/dist/agent/src/agent/tools/openUrlTool.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openURL = openURL;
+exports.openURLTool = openURLTool;
+const toolSettings_1 = require("../toolSettings");
+const utils_1 = require("./utils");
+const htmlToText_1 = require("./contentExtractors/htmlToText");
+const pdfToText_1 = require("./contentExtractors/pdfToText");
+const OPEN_URL_DESC = {
+    type: "function",
+    function: {
+        name: "open_url",
+        description: "Download and extract text content from a URL (supports HTML and PDF)",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "URL to download (HTML pages or PDF files)",
+                },
+            },
+            required: ["url"],
+        },
+    },
+};
+async function openURL(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        const status = String(response.status);
+        const code = response.statusText;
+        throw new Error(`Failed to fetch ${url}: ${status} ${code}`);
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const isPdf = contentType.includes("application/pdf") ||
+        url.toLowerCase().endsWith(".pdf");
+    if (isPdf) {
+        const buffer = await response.arrayBuffer();
+        return (0, pdfToText_1.pdfToText)(buffer, toolSettings_1.OPEN_URL_MAX_LENGTH);
+    }
+    else {
+        const html = await response.text();
+        return (0, htmlToText_1.htmlToText)(html, toolSettings_1.OPEN_URL_MAX_LENGTH);
+    }
+}
+function openURLTool() {
+    const getURL = (0, utils_1.makeParseArgsFn)(["url"]);
+    const toolFn = async (_, args) => {
+        const { url } = getURL(args);
+        return { response: await openURL(url) };
+    };
+    return {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        setup: async (agent) => {
+            agent.addAgentTool(OPEN_URL_DESC, toolFn);
+        },
+    };
+}

package/dist/agent/src/agent/tools/renderTool.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTool = renderTool;
+const utils_1 = require("./utils");
+const RENDER_DESC = {
+    type: "function",
+    function: {
+        name: "render",
+        description: [
+            "Display HTML using only safe elements",
+            "Never include <script>, <iframe>, <object>, <embed>, <form>, <meta>,",
+            "<link>, <style>, event handlers (onclick, etc.), or javascript: URLs.",
+            "If the tool result is [HTML_SANITIZATION_WARNING], do not mention it.",
+            "Retry with only safe elements. If warning repeats, tell the user you",
+            "cannot render unsafe HTML.",
+        ].join(" "),
+        parameters: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Filename for the HTML" },
+                summary: { type: "string", description: "One line summary" },
+                html: { type: "string", description: "HTML fragment to render" },
+            },
+            required: ["name", "summary", "html"],
+        },
+    },
+};
+function validateHtmlSafety(html) {
+    const issues = [];
+    if (/<script[\s>]/i.test(html))
+        issues.push("<script> tag");
+    if (/<iframe[\s>]/i.test(html))
+        issues.push("<iframe> tag");
+    if (/<object[\s>]/i.test(html))
+        issues.push("<object> tag");
+    if (/<embed[\s>]/i.test(html))
+        issues.push("<embed> tag");
+    if (/\bon\w+\s*=/.test(html))
+        issues.push("event handler (e.g., onclick)");
+    if (/javascript:/i.test(html))
+        issues.push("javascript: URL");
+    if (/<meta[\s>]/i.test(html))
+        issues.push("<meta> tag");
+    if (/<form[\s>]/i.test(html))
+        issues.push("<form> tag");
+    if (/<style[\s>]/i.test(html))
+        issues.push("<style> tag");
+    if (/<link[\s>]/i.test(html))
+        issues.push("<link> tag");
+    if (issues.length > 0) {
+        return `Unsafe HTML: ${issues.join(", ")}`;
+    }
+    return undefined;
+}
+function renderTool(fileManager) {
+    const getNameSummeryHtml = (0, utils_1.makeParseArgsFn)([
+        "name",
+        "summary",
+        "html",
+    ]);
+    const toolFn = async (_, args) => {
+        const { name, summary, html } = getNameSummeryHtml(args);
+        const safetyError = validateHtmlSafety(html);
+        if (safetyError) {
+            return {
+                response: "[HTML_SANITIZATION_WARNING]",
+                overwriteResponse: "",
+                structuredContent: {
+                    kind: "htmlSanitizationWarning",
+                    message: safetyError,
+                },
+            };
+        }
+        const mimeType = "text/html";
+        const dataURL = `data:${mimeType},${html}`;
+        await fileManager.putFileContent(name, summary, dataURL);
+        const uri = fileManager.getSessionFileRelativeUrl(name);
+        return {
+            response: "",
+            _meta: { "xalia/fileUri": uri, "xalia/fileMimeType": mimeType },
+        };
+    };
+    return {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        setup: async (agent) => {
+            agent.addAgentTool(RENDER_DESC, toolFn);
+        },
+    };
+}