@xalia/agent 0.6.0 → 0.6.2

package/dist/agent/src/chat/server/sessionFileManager.js

@@ -1,18 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatSessionFileManager = exports.MemoryFileManager = exports.SESSION_FILE_TYPES = void 0;
+exports.ChatSessionFileManager = exports.MemoryFileManager = void 0;
 exports.listFilesForLLM = listFilesForLLM;
 exports.fileManagerTool = fileManagerTool;
 const uuid_1 = require("uuid");
+const assert_1 = require("assert");
 const tools_1 = require("./tools");
-exports.SESSION_FILE_TYPES = ["text", "image", "pdf"];
+const dbSessionFiles_1 = require("../data/dbSessionFiles");
+const dbSessionFileModels_1 = require("../data/dbSessionFileModels");
 /**
  * In-memory implementation of ISessionFileManager
  */
 class MemoryFileManager {
     constructor() {
         this.files = new Map();
-        this.eventHandler = undefined;
+        this.eventHandlers = [];
     }
     // ISessionFileManager.listFiles
     listFiles() {
@@ -23,7 +25,22 @@ class MemoryFileManager {
         return new Promise((r, e) => {
             const entry = this.files.get(name);
             if (entry) {
-                r(entry.content);
+                r(entry.data_url);
+            }
+            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}`));
@@ -31,7 +48,7 @@ class MemoryFileManager {
         });
     }
     // ISessionFileManager.addFile
-    putFileContent(name, file_type, summary, content) {
+    putFileContent(name, summary, data_url) {
         return new Promise((r, e) => {
             if (!name) {
                 name = (0, uuid_1.v4)();
@@ -43,29 +60,114 @@ class MemoryFileManager {
                 e(new Error("summary must no contain new-lines"));
             }
             else {
-                const entry = { name, file_type, summary, content };
-                this.eventHandler?.onFileChange(entry);
+                const mime_type = (0, dbSessionFileModels_1.getSessionFileMimeTypeFromDataUrl)(data_url);
+                const is_new = !this.files.has(name);
+                const entry = { name, mime_type, summary, data_url };
+                this.eventHandlers.forEach((eh) => {
+                    eh.onFileChanged(entry, is_new);
+                });
                 this.files.set(name, entry);
-                r(name);
+                r({ name, mime_type, summary });
             }
         });
     }
     // ISessionFileManager.setEventHandler
-    setEventHandler(eventHandler) {
-        this.eventHandler = eventHandler;
+    addEventHandler(eventHandler) {
+        this.eventHandlers.push(eventHandler);
     }
 }
 exports.MemoryFileManager = MemoryFileManager;
 /**
  * Implementation of ISessionFileManager which can store files in the DB.
  */
-class ChatSessionFileManager extends MemoryFileManager {
-    // private readonly db: Database;
-    // private readonly sessionUUID: string;
-    constructor(_sessionUUID, _db) {
-        super();
-        // this.db = db;
-        // this.sessionUUID = sessionUUID;
+class ChatSessionFileManager {
+    constructor(sfc, sessionUUID, fileMap) {
+        this.sessionUUID = sessionUUID;
+        this.sfc = sfc;
+        this.eventHandlers = [];
+        this.fileMap = fileMap;
+        this.fileDataCache = new Map();
+    }
+    static async init(db, sessionUUID) {
+        const sfc = db.createTypedClient(dbSessionFiles_1.DbSessionFiles);
+        const fileList = await sfc.getFilesForSession(sessionUUID);
+        const fileMap = new Map(fileList.map((f) => [f.name, f]));
+        return new ChatSessionFileManager(sfc, sessionUUID, fileMap);
+    }
+    listFiles() {
+        return Array.from(this.fileMap.values());
+    }
+    async getFileContent(name) {
+        const cached = this.fileDataCache.get(name);
+        if (cached) {
+            return cached;
+        }
+        if (!this.fileMap.has(name)) {
+            throw new Error(`no file '${name}' in session '${this.sessionUUID}'`);
+        }
+        const fileData = await this.sfc.getFileContent(this.sessionUUID, name);
+        if (!fileData) {
+            // logically should not happen
+            throw new Error(`empty file '${name}' in session '${this.sessionUUID}'`);
+        }
+        this.fileDataCache.set(name, fileData);
+        return fileData;
+    }
+    // ISessionFileManager.deleteFile
+    async deleteFile(name) {
+        if (this.fileMap.has(name)) {
+            this.fileMap.delete(name);
+            this.fileDataCache.delete(name);
+            await this.sfc.deleteFile(this.sessionUUID, name);
+            this.eventHandlers.forEach((eh) => {
+                eh.onFileDeleted(name);
+            });
+        }
+        else {
+            throw new Error(`no file '${name}' in session '${this.sessionUUID}'`);
+        }
+    }
+    // ISessionFileManager.addFile
+    async putFileContent(name, summary, data_url) {
+        if (!name) {
+            // TODO: have the LLM fill in the name?
+            name = (0, uuid_1.v4)();
+        }
+        // TODO: have the LLM create summary if missing?
+        // If we have an existing entry in the cache then update it, otherwise
+        // create a new one.
+        const mime_type = (0, dbSessionFileModels_1.getSessionFileMimeTypeFromDataUrl)(data_url);
+        const existingDesc = this.fileMap.get(name);
+        if (existingDesc) {
+            existingDesc.summary = summary;
+            existingDesc.mime_type = mime_type;
+        }
+        else {
+            this.fileMap.set(name, { name, summary, mime_type });
+        }
+        const is_new = !this.fileMap.has(name);
+        this.fileDataCache.set(name, data_url);
+        await this.sfc.setFileContent(this.sessionUUID, name, summary, data_url);
+        this.eventHandlers.forEach((eh) => {
+            (0, assert_1.strict)(typeof name === "string");
+            eh.onFileChanged({ name, summary, mime_type, data_url }, is_new);
+        });
+        return { name, mime_type, summary };
+    }
+    // ISessionFileManager.setEventHandler
+    addEventHandler(eventHandler) {
+        this.eventHandlers.push(eventHandler);
+    }
+    clearAllFiles() {
+        this.fileMap.clear();
+        this.fileDataCache.clear();
+        return this.sfc.clearFiles(this.sessionUUID);
+    }
+    getSessionFileRelativeUrl(name) {
+        return `file+session:/./${name}`;
+    }
+    getSessionFileAbsoluteUrl(name) {
+        return `file+session://${this.sessionUUID}/${name}`;
     }
 }
 exports.ChatSessionFileManager = ChatSessionFileManager;
@@ -79,7 +181,7 @@ function listFilesForLLM(fm) {
     }
     let summary = "Available files:\nname,type,summary\n";
     for (const f of files) {
-        summary += `${f.name},${f.file_type},${f.summary || ""}\n`;
+        summary += `${f.name},${f.mime_type},${f.summary || ""}\n`;
     }
     return summary;
 }
@@ -87,7 +189,7 @@ const GET_FILE_CONTENT_TOOL = {
     type: "function",
     function: {
         name: "get_file_content",
-        description: "Obtain the contents of a file listed in the system prompt",
+        description: "Obtain contents of file listed in system prompt, as data-url",
         parameters: {
             type: "object",
             properties: {
@@ -112,49 +214,80 @@ const PUT_FILE_CONTENT_TOOL = {
                     type: "string",
                     description: "File name",
                 },
-                file_type: {
-                    type: "string",
-                    enum: exports.SESSION_FILE_TYPES,
-                },
                 summary: {
                     type: "string",
                     description: "Content summary",
                 },
-                content: {
+                data_url: {
                     type: "string",
-                    description: "Content (text/dataurl)",
+                    description: "Content data-url: `data:<mime-type>[;<format>],<encoding>`",
                 },
             },
-            required: ["name", "type", "summary", "content"],
+            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"],
         },
     },
 };
 function fileManagerTool(fileManager) {
-    // get_file_content
-    const getName = (0, tools_1.makeParseArgsFn)(["name"]);
+    // `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, tools_1.makeParseArgsFn)(["name"]);
     const getFileContentFn = async (_agent, args) => {
-        const { name } = getName(args);
+        const { name } = parseName(args);
         const response = await fileManager.getFileContent(name);
-        return { response };
+        const overwriteResponse = fileManager.getSessionFileRelativeUrl(name);
+        return { response, overwriteResponse };
     };
-    // set_file_content
-    const putArgs = ["name", "file_type", "summary", "content"];
-    const getNameSummaryContent = (0, tools_1.makeParseArgsFn)(putArgs);
+    // `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, tools_1.makeParseArgsFn)(putArgs);
     const putFileContentFn = async (_, args) => {
-        const { name, file_type, summary, content } = getNameSummaryContent(args);
-        const response = await fileManager.putFileContent(name, file_type, summary, content);
-        return { response };
+        const parsed = parseNameSummaryDataUrl(args);
+        const { name, summary, data_url } = parsed;
+        const desc = await fileManager.putFileContent(name, summary, data_url);
+        parsed.data_url = fileManager.getSessionFileRelativeUrl(name);
+        return { response: desc.name, overwriteArgs: JSON.stringify(parsed) };
+    };
+    // `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: "" };
     };
-    const provider = {
+    return {
         setup: (agent) => {
             agent.addAgentTool(GET_FILE_CONTENT_TOOL, getFileContentFn);
             agent.addAgentTool(PUT_FILE_CONTENT_TOOL, putFileContentFn);
+            agent.addAgentTool(DELETE_FILE_CONTENT_TOOL, deleteFileFn);
             return new Promise((r) => {
                 r();
             });
         },
     };
-    return provider;
 }
 function isSingleLine(str) {
     return !/[\r\n]/.test(str);