@smythos/sre 1.5.53 → 1.5.54

package/src/subsystems/MemoryManager/Cache.service/index.ts

@@ -1,15 +1,15 @@
-//==[ SRE: Cache ]======================
-import { ConnectorServiceProvider, ConnectorService } from '@sre/Core/ConnectorsService';
-import { TConnectorService } from '@sre/types/SRE.types';
-import { RedisCache } from './connectors/RedisCache.class';
-import { S3Cache } from './connectors/S3Cache.class';
-import { LocalStorageCache } from './connectors/LocalStorageCache.class';
-import { RAMCache } from './connectors/RAMCache.class';
-export class CacheService extends ConnectorServiceProvider {
-    public register() {
-        ConnectorService.register(TConnectorService.Cache, 'Redis', RedisCache);
-        ConnectorService.register(TConnectorService.Cache, 'S3', S3Cache);
-        ConnectorService.register(TConnectorService.Cache, 'LocalStorage', LocalStorageCache);
-        ConnectorService.register(TConnectorService.Cache, 'RAM', RAMCache);
-    }
-}
+//==[ SRE: Cache ]======================
+import { ConnectorServiceProvider, ConnectorService } from '@sre/Core/ConnectorsService';
+import { TConnectorService } from '@sre/types/SRE.types';
+import { RedisCache } from './connectors/RedisCache.class';
+import { S3Cache } from './connectors/S3Cache.class';
+import { LocalStorageCache } from './connectors/LocalStorageCache.class';
+import { RAMCache } from './connectors/RAMCache.class';
+export class CacheService extends ConnectorServiceProvider {
+    public register() {
+        ConnectorService.register(TConnectorService.Cache, 'Redis', RedisCache);
+        ConnectorService.register(TConnectorService.Cache, 'S3', S3Cache);
+        ConnectorService.register(TConnectorService.Cache, 'LocalStorage', LocalStorageCache);
+        ConnectorService.register(TConnectorService.Cache, 'RAM', RAMCache);
+    }
+}

package/src/subsystems/MemoryManager/LLMCache.ts

@@ -1,72 +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);
-    }
-}
+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

@@ -1,124 +1,124 @@
-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() {        
-        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 = '',
-        llmContextStore?: ILLMContextStore,
-    ) {
-        this._llmCache = new LLMCache(AccessCandidate.team(this.llmInference.teamId));
-        //this._systemPrompt = _systemPrompt;
-        this.systemPrompt = _systemPrompt;
-
-        
-        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);
-        
-        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);
-    }
-}
+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() {        
+        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 = '',
+        llmContextStore?: ILLMContextStore,
+    ) {
+        this._llmCache = new LLMCache(AccessCandidate.team(this.llmInference.teamId));
+        //this._systemPrompt = _systemPrompt;
+        this.systemPrompt = _systemPrompt;
+
+        
+        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);
+        
+        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/LLMMemory.service/LLMMemoryConnector.ts

@@ -1,26 +1,26 @@
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-import { ACL } from '@sre/Security/AccessControl/ACL.class';
-import { SecureConnector } from '@sre/Security/SecureConnector.class';
-import { IAccessCandidate } from '@sre/types/ACL.types';
-
-export interface ILLMMemoryRequest {
-    load: (messages: any[]) => Promise<any>;
-
-
-}
-
-export abstract class LLMMemoryConnector extends SecureConnector {
-    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
-    public requester(candidate: AccessCandidate): ILLMMemoryRequest {
-        return {
-            load: async (messages: any[]) => {
-                return await this.load(candidate.readRequest, messages);
-            },            
-        };
-    }
-
-    abstract load(acRequest: AccessRequest, messages: any[]): Promise<any>;
-
-
-}
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+
+export interface ILLMMemoryRequest {
+    load: (messages: any[]) => Promise<any>;
+
+
+}
+
+export abstract class LLMMemoryConnector extends SecureConnector {
+    public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    public requester(candidate: AccessCandidate): ILLMMemoryRequest {
+        return {
+            load: async (messages: any[]) => {
+                return await this.load(candidate.readRequest, messages);
+            },            
+        };
+    }
+
+    abstract load(acRequest: AccessRequest, messages: any[]): Promise<any>;
+
+
+}