@smythos/sre 1.5.1 → 1.5.4

package/src/subsystems/MemoryManager/LLMCache.ts

@@ -0,0 +1,72 @@
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { CacheConnector } from './Cache.service/CacheConnector';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { uid } from '@sre/utils/index';
+
+export type LLMCacheObject = {
+    ttl: number;
+    data: any;
+};
+
+export class LLMCache {
+    private _cacheConnector: CacheConnector;
+    private _cacheId: string;
+    private _ttl: number;
+    private _candidate: AccessCandidate;
+
+    public get id() {
+        return this._cacheId;
+    }
+
+    /**
+     * Creates a new LLMCache instace for a smythOS actor, the actor can be an agent, a user or a team
+     * This is mainly use with agent to maintain a cache of the current LLM context
+     *
+     * This class can be used to share llm contexts data accross multiple instances of an agent, or between a ConversationHelper and a remote agent
+     *
+     * @param candidate
+     * @param cacheId
+     * @param ttl
+     */
+    constructor(candidate: AccessCandidate, cacheId?: string, ttl: number = 1 * 60 * 60) {
+        this._cacheConnector = ConnectorService.getCacheConnector();
+        this._cacheId = cacheId || 'llm_cache_' + uid();
+        this._ttl = ttl;
+        this._candidate = candidate;
+    }
+
+    async set(key: string, data: any) {
+        if (!this._cacheConnector.valid) return;
+
+        await this._cacheConnector
+            .requester(this._candidate)
+            .set(`${this._cacheId}:${key}`, typeof data === 'object' ? JSON.stringify(data) : data, null, null, this._ttl);
+    }
+    async get(key: string, format: 'json' | 'text' = 'json') {
+        if (!this._cacheConnector.valid) return;
+
+        const obj = await this._cacheConnector.requester(this._candidate).get(`${this._cacheId}:${key}`);
+        let result;
+        if (format === 'json') {
+            try {
+                result = JSON.parse(obj);
+            } catch (e) {
+                console.warn(`Invalid JSON data for key ${key}`);
+                result = null;
+            }
+        } else {
+            result = obj;
+        }
+        return result;
+    }
+    async delete(key: string) {
+        if (!this._cacheConnector.valid) return;
+
+        await this._cacheConnector.requester(this._candidate).delete(`${this._cacheId}:${key}`);
+    }
+    async clear() {
+        if (!this._cacheConnector.valid) return;
+
+        await this._cacheConnector.requester(this._candidate).delete(this._cacheId);
+    }
+}

package/src/subsystems/MemoryManager/LLMContext.ts

@@ -0,0 +1,125 @@
+import { encode, encodeChat } from 'gpt-tokenizer';
+import { ChatMessage } from 'gpt-tokenizer/esm/GptEncoding';
+import { ILLMContextStore } from '@sre/types/LLM.types';
+import { LLMCache } from './LLMCache';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+//content, name, role, tool_call_id, tool_calls, function_call
+export class LLMContext {
+    private _systemPrompt: string = '';
+    private _llmContextStore: ILLMContextStore;
+    private _llmCache: LLMCache;
+
+    public get systemPrompt() {
+        return this._systemPrompt;
+    }
+    public set systemPrompt(systemPrompt) {
+        this._systemPrompt = systemPrompt;
+        this._llmCache?.set('systemPrompt', this.systemPrompt);
+    }
+
+    public get llmCache() {
+        return this._llmCache;
+    }
+
+    public contextLength: number;
+
+    private _messages: any[] = [];
+    public get messages() {
+        //TODO : check if the store is ready
+        return this._messages;
+    }
+
+    public get model() {
+        return this.llmInference.model;
+    }
+    /**
+     *
+     * @param source a messages[] object, or smyth file system uri (smythfs://...)
+     */
+    constructor(
+        private llmInference,
+        _systemPrompt: string = '',
+        /*private _messages: any[] = [],*/ llmContextStore?: ILLMContextStore,
+    ) {
+        this._llmCache = new LLMCache(AccessCandidate.team(this.llmInference.teamId));
+        //this._systemPrompt = _systemPrompt;
+        this.systemPrompt = _systemPrompt;
+
+        //TODO:allow configuring a storage service
+        if (llmContextStore) {
+            this._llmContextStore = llmContextStore;
+            this._llmContextStore.load().then((messages) => {
+                this._messages = messages;
+                this._llmCache.set('messages', this._messages);
+            });
+        }
+    }
+
+    private push(...message: any[]) {
+        this._messages.push(...message);
+        //TODO: persist to storage
+        if (this._llmContextStore) {
+            this._llmContextStore.save(this._messages);
+        }
+        this._llmCache.set('messages', this._messages);
+    }
+    public addUserMessage(content: string, message_id: string, metadata?: any) {
+        //in the current implementation, we do not support forked conversations
+        //we always attatch to the last message in the queue
+
+        //TODO: implement forked conversations ==> might require updating the interfaces in order to support passing previous message_id explicitly
+        const lastMessage = this._messages[this._messages.length - 1];
+
+        if (lastMessage) {
+            if (!lastMessage.__smyth_data__?.next) {
+                lastMessage.__smyth_data__.next = [];
+            }
+            lastMessage.__smyth_data__.next.push(message_id);
+        }
+
+        const prev = lastMessage?.__smyth_data__?.message_id;
+        const next = [];
+
+        this.push({ role: 'user', content, __smyth_data__: { message_id, ...metadata, prev, next } });
+    }
+    public addAssistantMessage(content: string, message_id: string, metadata?: any) {
+        const lastMessage = this._messages[this._messages.length - 1];
+
+        if (lastMessage) {
+            if (!lastMessage.__smyth_data__?.next) {
+                lastMessage.__smyth_data__.next = [];
+            }
+            lastMessage.__smyth_data__.next.push(message_id);
+        }
+
+        const prev = lastMessage?.__smyth_data__?.message_id;
+        const next = [];
+        this.push({ role: 'assistant', content, __smyth_data__: { message_id, ...metadata, prev, next } });
+    }
+    public addToolMessage(messageBlock: any, toolsData: any, message_id: string, metadata?: any) {
+        const lastMessage = this._messages[this._messages.length - 1];
+
+        if (lastMessage) {
+            if (!lastMessage.__smyth_data__?.next) {
+                lastMessage.__smyth_data__.next = [];
+            }
+            lastMessage.__smyth_data__.next.push(message_id);
+        }
+
+        const prev = lastMessage?.__smyth_data__?.message_id;
+        const next = [];
+        this.push({ messageBlock, toolsData, __smyth_data__: { message_id, ...metadata, prev, next } });
+    }
+
+    public async getContextWindow(maxTokens: number, maxOutputTokens: number = 1024): Promise<any[]> {
+        const messages = JSON.parse(JSON.stringify(this._messages));
+        // if (messages[0]?.role === 'system') {
+        //     messages[0].content = this.systemPrompt;
+        // } else {
+        //     messages.unshift({ role: 'system', content: this.systemPrompt });
+        // }
+
+        return this.llmInference.getContextWindow(this.systemPrompt, messages, maxTokens, maxOutputTokens);
+    }
+}

package/src/subsystems/MemoryManager/RuntimeContext.ts

@@ -0,0 +1,249 @@
+import EventEmitter from 'events';
+import { delay, uid } from '@sre/utils';
+import { AgentRuntime } from '@sre/AgentManager/AgentRuntime.class';
+import { Logger } from '@sre/helpers/Log.helper';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { CacheConnector } from './Cache.service/CacheConnector';
+
+const console = Logger('RuntimeContext');
+
+type TRuntimeData = {
+    input?: { [key: string]: any };
+    _LoopData?: any;
+    _ChildLoopData?: any;
+};
+type TComponentContext = {
+    active: boolean;
+    name: string;
+    runtimeData?: TRuntimeData;
+    step: number;
+    input?: { [key: string]: any };
+    output?: { [key: string]: any };
+};
+export class RuntimeContext extends EventEmitter {
+    public circularLimitReached: string | boolean = false;
+    public step: number = 0;
+    public sessionResult: boolean = false;
+    public sessionResults: any;
+    public components: { [id: string]: { ctx: TComponentContext } } = {};
+
+    public checkRuntimeContext: any = null;
+
+    private ctxFile: string = '';
+    private _runtimeFileReady: any;
+    private _cacheConnector: CacheConnector;
+
+    private _readyPromise: Promise<boolean>;
+
+    constructor(private runtime: AgentRuntime) {
+        super();
+        const agent = runtime.agent;
+
+        this._cacheConnector = ConnectorService.getCacheConnector();
+
+        const processRootID = runtime.processID?.split(':')[0] || '';
+        const reqId = processRootID == runtime.xDebugId ? '' : '.' + uid() + runtime.reqTag;
+
+        this.ctxFile = `${runtime.xDebugId}${reqId}${agent.jobID ? `-job-${agent.jobID}` : ''}`;
+
+        this._readyPromise = new Promise((resolve, reject) => {
+            let resolved = false;
+            this.on('ready', () => {
+                resolved = true;
+                resolve(true);
+            });
+            const timer = setTimeout(() => {
+                if (!resolved) {
+                    reject(new Error('Agent Runtime context initialization timeout'));
+                }
+            }, 5 * 60 * 1000);
+            timer.unref(); //unblock the event loop
+        });
+
+        this.initRuntimeContext();
+    }
+
+    private serialize() {
+        const data = {
+            step: this.step,
+            sessionResult: this.sessionResult,
+            sessionResults: this.sessionResults,
+            components: this.components,
+        };
+
+        return data;
+    }
+    private deserialize(data: any) {
+        this.step = data.step;
+        this.sessionResult = data.sessionResult;
+        this.sessionResults = data.sessionResults;
+        this.components = data.components;
+    }
+    private reset() {
+        this.step = 0;
+        this.sessionResult = false;
+        this.sessionResults = null;
+        this.components = {};
+    }
+
+    private initRuntimeContext() {
+        if (this._runtimeFileReady) return;
+
+        const endpointDBGCall = this.runtime.xDebugId?.startsWith('dbg-'); //weak check for debug session, we need to improve this
+        console.debug('Init ctxFile', this.ctxFile);
+        const agent = this.runtime.agent;
+        let method = (agent.agentRequest.method || 'POST').toUpperCase();
+        const endpoint = agent.endpoints?.[agent.agentRequest.path]?.[method];
+
+        let ctxData: any = {};
+
+        this._cacheConnector
+            .requester(AccessCandidate.agent(this.runtime.agent.id))
+            .get(this.ctxFile)
+            .then(async (data) => {
+                if (!data) {
+                    ctxData = JSON.parse(JSON.stringify({ components: agent.components, connections: agent.connections, timestamp: Date.now() }));
+                    if (!ctxData.step) ctxData.step = 0;
+                    for (let cptId in ctxData.components) {
+                        ctxData.components[cptId] = {
+                            id: cptId,
+                            name: ctxData.components[cptId].name,
+                            //dbg: { active: false, name: ctxData.components[cptId].name },
+                            ctx: { active: false, name: ctxData.components[cptId].name },
+                        };
+
+                        const cpt = ctxData.components[cptId];
+                        //if this debug session was initiated from an endpoint, we mark the endpoint component as active
+                        if (endpoint && endpoint.id != undefined && cpt.id == endpoint.id && endpointDBGCall) {
+                            //cpt.dbg.active = true;
+                            cpt.ctx.active = true;
+                        }
+                    }
+                    //fs.writeFileSync(this.ctxFile, JSON.stringify(ctxData, null, 2));
+                    await this._cacheConnector
+                        .requester(AccessCandidate.agent(this.runtime.agent.id))
+                        .set(this.ctxFile, JSON.stringify(ctxData, null, 2), null, null, 6 * 60 * 60); //expires in 6 hours max
+                } else {
+                    ctxData = JSON.parse(data);
+                    if (!ctxData.step) ctxData.step = 0;
+                }
+
+                this.deserialize(ctxData);
+                this._runtimeFileReady = true;
+                this.emit('ready');
+            });
+
+        // if (!fs.existsSync(this.ctxFile)) {
+        //     ctxData = JSON.parse(JSON.stringify({ components: agent.components, connections: agent.connections, timestamp: Date.now() }));
+        //     if (!ctxData.step) ctxData.step = 0;
+        //     for (let cptId in ctxData.components) {
+        //         ctxData.components[cptId] = {
+        //             id: cptId,
+        //             name: ctxData.components[cptId].name,
+        //             //dbg: { active: false, name: ctxData.components[cptId].name },
+        //             ctx: { active: false, name: ctxData.components[cptId].name },
+        //         };
+
+        //         const cpt = ctxData.components[cptId];
+        //         //if this debug session was initiated from an endpoint, we mark the endpoint component as active
+        //         if (endpoint && endpoint.id != undefined && cpt.id == endpoint.id && endpointDBGCall) {
+        //             //cpt.dbg.active = true;
+        //             cpt.ctx.active = true;
+        //         }
+        //     }
+        //     fs.writeFileSync(this.ctxFile, JSON.stringify(ctxData, null, 2));
+        // } else {
+        //     ctxData = JSON.parse(fs.readFileSync(this.ctxFile, 'utf8'));
+        //     if (!ctxData.step) ctxData.step = 0;
+        // }
+
+        // this.deserialize(ctxData);
+        // this._runtimeFileReady = true;
+        // this.emit('ready');
+    }
+
+    public async ready() {
+        if (this._runtimeFileReady) return true;
+        return this._readyPromise;
+    }
+    public async sync() {
+        if (!this.ctxFile) return;
+        this.emit('syncing');
+
+        const deleteSession = this.runtime.sessionClosed;
+
+        if (deleteSession) {
+            const exists = await this._cacheConnector.requester(AccessCandidate.agent(this.runtime.agent.id)).exists(this.ctxFile);
+
+            if (exists) {
+                if (this.runtime.debug)
+                    this._cacheConnector
+                        .requester(AccessCandidate.agent(this.runtime.agent.id))
+                        .updateTTL(this.ctxFile, 5 * 60); //expires in 5 minute
+                else this._cacheConnector.requester(AccessCandidate.agent(this.runtime.agent.id)).delete(this.ctxFile);
+                //if (this.runtime.debug && fs.existsSync(this.ctxFile)) await delay(1000 * 60); //if we're in debug mode, we keep the file for a while to allow final state read
+                //if (fs.existsSync(this.ctxFile)) fs.unlinkSync(this.ctxFile);
+            }
+        } else {
+            const data = this.serialize();
+            //if (data) fs.writeFileSync(this.ctxFile, JSON.stringify(data, null, 2));
+            if (data)
+                await this._cacheConnector
+                    .requester(AccessCandidate.agent(this.runtime.agent.id))
+                    .set(this.ctxFile, JSON.stringify(data, null, 2), null, null, 6 * 60 * 60); //expires in 6 hours max
+        }
+    }
+
+    public incStep() {
+        this.step++;
+        this.sync();
+    }
+
+    public updateComponent(componentId: string, data: any) {
+        const ctxData = this;
+        if (!ctxData) return;
+        const component = ctxData.components[componentId];
+
+        if (!component) {
+            console.log('>>>>>>> updateComponent Component debug data not found', componentId, component);
+            console.log('>>> ctxFile', this.ctxFile);
+            console.log('>>> ctxData', ctxData);
+        }
+        component.ctx = { ...component.ctx, ...data, step: this.step };
+
+        //if (this.debug) component.dbg = { ...component.dbg, ...data };
+
+        this.sync();
+    }
+    public resetComponent(componentId: string) {
+        const ctxData = this;
+        const component = ctxData.components[componentId];
+        if (!component) {
+            console.log('>>>>>>> resetComponent Component debug data not found', componentId, component);
+            console.log('>>> ctxFile', this.ctxFile);
+            console.log('>>> ctxData', ctxData);
+        }
+        //component.dbg.active = false;
+        //component.dbg.runtimeData = {};
+        component.ctx.runtimeData = {};
+        component.ctx.active = false;
+
+        this.sync();
+    }
+
+    public getComponentData(componentId: string) {
+        const ctxData = this;
+        if (!ctxData) return null;
+        const component = ctxData.components[componentId];
+        if (!component) {
+            console.log('>>>>>>> getComponentData Component debug data not found', componentId, component);
+            console.log('>>> ctxFile', this.ctxFile);
+            console.log('>>> ctxData', ctxData);
+        }
+        //const data = this.debug ? component.dbg : component.ctx;
+        const data = component.ctx;
+
+        return data;
+    }
+}

package/src/subsystems/Security/AccessControl/ACL.class.ts

@@ -0,0 +1,208 @@
+//import { xxh3 } from '@node-rs/xxhash';
+import xxhash from 'xxhashjs';
+import { IACL, IAccessRequest, LevelMap, ReverseLevelMap, ReverseRoleMap, RoleMap, TACLEntry, TAccessLevel, TAccessRole } from '@sre/types/ACL.types';
+
+const ACLHashAlgo = {
+    none: (source) => source,
+    //xxh3: (source) => xxh3.xxh64(source.toString()).toString(16),
+    xxh3: (source) => {
+        const h64 = xxhash.h64(); // Use xxhashjs's h64 function
+        return source ? h64.update(source.toString()).digest().toString(16) : null;
+    },
+};
+
+export class ACL implements IACL {
+    public hashAlgorithm?: string | undefined;
+    public entries?: {
+        [key in TAccessRole]?: TACLEntry | undefined;
+    };
+    public migrated?: boolean | undefined;
+    //private acl: TACL;
+    public get ACL(): IACL {
+        return {
+            hashAlgorithm: this.hashAlgorithm,
+            entries: JSON.parse(JSON.stringify(this.entries)),
+            migrated: this.migrated,
+        };
+    }
+    public get serializedACL(): string {
+        return this.serializeACL(this);
+    }
+
+    constructor(acl?: IACL | string) {
+        if (typeof acl === 'string') {
+            this.deserializeACL(acl);
+        } else {
+            this.hashAlgorithm = acl?.hashAlgorithm;
+            this.entries = acl?.entries ? JSON.parse(JSON.stringify(acl?.entries)) : {};
+            this.migrated = acl?.migrated;
+        }
+        if (!this.hashAlgorithm) this.hashAlgorithm = 'xxh3';
+        if (!this.entries) this.entries = {};
+    }
+
+    static from(acl?: IACL | string): ACL {
+        return new ACL(acl);
+    }
+
+    /**
+     * This function checks if the candidate has access to the requested level
+     * it only checks the exact access level, not the higher levels
+     * Examples :
+     * - if the candidate has read access, it will return true only if the requested level is read
+     * - if the current ACL has team access but the candidate is an agent, it will not match the team access
+     * @param acRequest
+     * @returns
+     */
+    public checkExactAccess(acRequest: IAccessRequest): boolean {
+        if (!this?.entries) return false; // cannot determine the access rights, prefer to deny access
+
+        const role = this?.entries[acRequest.candidate.role];
+        if (!role) return false;
+        let entryId = acRequest.candidate.id;
+
+        if (!ACLHashAlgo[this.hashAlgorithm]) {
+            throw new Error(`Hash algorithm ${this.hashAlgorithm} not supported`);
+        }
+
+        entryId = ACLHashAlgo[this.hashAlgorithm](entryId);
+
+        const access = role[entryId];
+        if (!access) return false;
+
+        const levels = Array.isArray(acRequest.level) ? acRequest.level : [acRequest.level];
+
+        return levels.every((level) => access.includes(level));
+        //return access.includes(req.level);
+    }
+
+    public addPublicAccess(level: TAccessLevel | TAccessLevel[]): ACL {
+        if (!this?.entries[TAccessRole.Public]) this.entries[TAccessRole.Public] = {};
+        if (!ACLHashAlgo[this.hashAlgorithm]) {
+            throw new Error(`Hash algorithm ${this.hashAlgorithm} not supported`);
+        }
+        const ownerId = TAccessRole.Public; //public is a special case we use the role as the owner id because public access does not have specific candidate IDs
+        const hashedOwner = ACLHashAlgo[this.hashAlgorithm](ownerId);
+
+        if (!this?.entries[TAccessRole.Public]![hashedOwner]) this.entries[TAccessRole.Public]![hashedOwner] = [];
+        //acl[TAccessRole.Public]![hashedOwner]!.push(level);
+        //concatenate the levels
+        const curLevel: any = this.entries[TAccessRole.Public]![hashedOwner]!;
+        this.entries[TAccessRole.Public]![hashedOwner] = [...curLevel, ...level];
+
+        return this;
+    }
+    public removePublicAccess(level: TAccessLevel | TAccessLevel[]): ACL {
+        if (!this?.entries[TAccessRole.Public]) return this;
+        const ownerId = TAccessRole.Public; //public is a special case we use the role as the owner id because public access does not have specific candidate IDs
+        const hashedOwner = ACLHashAlgo[this.hashAlgorithm](ownerId);
+
+        //remove the levels
+        const curLevel = this[TAccessRole.Public]![hashedOwner]!;
+        this[TAccessRole.Public]![hashedOwner] = curLevel.filter((l) => !level.includes(l));
+
+        return this;
+    }
+    public addAccess(role: TAccessRole, ownerId: string, level: TAccessLevel | TAccessLevel[]): ACL {
+        if (role === TAccessRole.Public) {
+            throw new Error('Adding public access using addAccess method is not allowed. Use addPublicAccess method instead.');
+        }
+        const _level = Array.isArray(level) ? level : [level];
+        if (!this?.entries[role]) this.entries[role] = {};
+        if (!ACLHashAlgo[this.hashAlgorithm]) {
+            throw new Error(`Hash algorithm ${this.hashAlgorithm} not supported`);
+        }
+        const hashedOwner = ACLHashAlgo[this.hashAlgorithm](ownerId);
+
+        if (!hashedOwner) {
+            throw new Error(`Invalid ownerId: ${role}:${ownerId}`);
+        }
+
+        if (!this?.entries[role]![hashedOwner]) this.entries[role]![hashedOwner] = [];
+        //acl[role]![ownerId]!.push(level);
+        //concatenate the levels
+        const curLevel = this.entries[role]![hashedOwner]!;
+        this.entries[role]![hashedOwner] = [...curLevel, ..._level];
+
+        return this;
+    }
+    public static addAccess(role: TAccessRole, ownerId: string, level: TAccessLevel | TAccessLevel[]): ACL {
+        return ACL.from().addAccess(role, ownerId, level);
+    }
+
+    public removeAccess(role: TAccessRole, ownerId: string, level: TAccessLevel | TAccessLevel[]): ACL {
+        const _level = Array.isArray(level) ? level : [level];
+        if (!this[role]) return this;
+        if (!this[role]![ownerId]) return this;
+        //acl[role]![ownerId] = acl[role]![ownerId]!.filter((l) => l !== level);
+        //remove the levels
+        const curLevel = this[role]![ownerId]!;
+        this[role]![ownerId] = curLevel.filter((l) => !_level.includes(l));
+
+        return this;
+    }
+
+    private serializeACL(tacl: IACL): string {
+        let compressed = '';
+
+        if (tacl.hashAlgorithm) {
+            compressed += `h:${tacl.hashAlgorithm}|`;
+        }
+
+        if (tacl.entries) {
+            for (const [role, entries] of Object.entries(tacl.entries)) {
+                const roleShort = RoleMap[role]; // Use the mapping for role
+                const entriesArray: any[] = [];
+
+                for (const [hashedOwnerKey, accessLevels] of Object.entries(entries || {})) {
+                    if (accessLevels) {
+                        const accessLevelsShort = accessLevels.map((level) => LevelMap[level]).join('');
+                        entriesArray.push(`${hashedOwnerKey}/${accessLevelsShort}`);
+                    }
+                }
+
+                if (entriesArray.length > 0) {
+                    compressed += `${roleShort}:${entriesArray.join(',')}|`;
+                }
+            }
+        }
+
+        // Remove the trailing '|'
+        if (compressed.endsWith('|')) {
+            compressed = compressed.slice(0, -1);
+        }
+
+        return compressed;
+    }
+
+    private deserializeACL(compressed: string) {
+        const parts = compressed.split('|');
+        this.hashAlgorithm = '';
+        this.entries = {};
+
+        for (const part of parts) {
+            if (part.startsWith('h:')) {
+                this.hashAlgorithm = part.substring(2);
+            } else {
+                const [roleShort, entries] = part.split(':');
+                const role = ReverseRoleMap[roleShort]; // Use the reverse mapping for role
+
+                if (role) {
+                    const entriesObj = {};
+                    const entriesArray = entries.split(',');
+
+                    for (const entry of entriesArray) {
+                        const [hashedOwnerKey, accessLevelsShort] = entry.split('/');
+                        const accessLevels = accessLevelsShort.split('').map((short) => ReverseLevelMap[short]);
+
+                        entriesObj[hashedOwnerKey] = accessLevels;
+                    }
+
+                    this.entries[role] = entriesObj;
+                }
+            }
+        }
+
+        //return tacl;
+    }
+}