enhanced Electron support

fix wrong display of vault search directory
SDK : adding the possibility to enable and disable planner mode

Author: alaa-eddine

packages/core/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@smythos/sre",
-    "version": "1.6.13",
+    "version": "1.6.14",
     "description": "Smyth Runtime Environment",
     "author": "Alaa-eddine KADDOURI",
     "license": "MIT",

packages/core/src/helpers/Sysconfig.helper.ts

@@ -31,8 +31,23 @@ export function findSmythPath(_path: string = '', callback?: (smythDir: string,
         return envDir;
     }
 
+    const isElectron = !!process.versions.electron;
+    let execPath = '';
+    if (isElectron) {
+        // In packaged Electron apps, use resourcesPath if available
+        if ((process as any).resourcesPath) {
+            // process.resourcesPath points to the 'resources' folder in packaged app
+            // Go up one level to get the app directory
+            execPath = path.dirname((process as any).resourcesPath);
+        } else {
+            // Development mode or fallback
+            execPath = path.dirname(process.execPath);
+        }
+    } else {
+        execPath = process.cwd();
+    }
     // 1. Try to find in local directory (the directory from which the program was run)
-    const localDir = path.resolve(process.cwd(), '.smyth', _path);
+    const localDir = path.resolve(execPath, '.smyth', _path);
     searchDirectories.push(localDir);
 
     // 2. Try to find from main script's directory (entry point)
@@ -61,10 +76,11 @@ export function findSmythPath(_path: string = '', callback?: (smythDir: string,
     const homeDir = path.resolve(os.homedir(), '.smyth', _path);
     searchDirectories.push(homeDir);
 
+    const deduplicatedSearchDirectories = Array.from(new Set(searchDirectories));
     //check if any of the directories exist
-    for (let i = 0; i < searchDirectories.length; i++) {
-        const dir = searchDirectories[i];
-        const nextDir = searchDirectories[i + 1];
+    for (let i = 0; i < deduplicatedSearchDirectories.length; i++) {
+        const dir = deduplicatedSearchDirectories[i];
+        const nextDir = deduplicatedSearchDirectories[i + 1];
         if (!fs.existsSync(dir)) {
             callback?.(dir, false, nextDir);
             continue;
@@ -82,7 +98,8 @@ export function findSmythPath(_path: string = '', callback?: (smythDir: string,
 
 export function findValidResourcePath(listOfLocations: string[], callback?: (dir: string, success?: boolean, nextDir?: string) => void) {
     let found = '';
-    for (let location of listOfLocations) {
+    const deduplicatedLocations = Array.from(new Set(listOfLocations));
+    for (let location of deduplicatedLocations) {
         findSmythPath(location, (dir, success, nextDir) => {
             callback?.(dir, success, nextDir);
             if (success) {
@@ -93,16 +110,35 @@ export function findValidResourcePath(listOfLocations: string[], callback?: (dir
     }
     return found;
 }
-function findPackageRoot(startDir = process.cwd()) {
-    let currentDir = startDir;
-
-    while (currentDir !== path.dirname(currentDir)) {
-        const packageJsonPath = path.resolve(currentDir, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            return currentDir;
+function findPackageRoot(startDir?) {
+    try {
+        if (!startDir) {
+            const isElectron = !!process.versions.electron;
+            let execPath = '';
+            if (isElectron) {
+                // In packaged Electron apps, use resourcesPath if available
+                if ((process as any).resourcesPath) {
+                    // process.resourcesPath points to the 'resources' folder in packaged app
+                    // Go up one level to get the app directory
+                    execPath = path.dirname((process as any).resourcesPath);
+                } else {
+                    // Development mode or fallback
+                    execPath = path.dirname(process.execPath);
+                }
+            } else {
+                execPath = process.cwd();
+            }
+            startDir = execPath;
         }
-        currentDir = path.dirname(currentDir);
-    }
+        let currentDir = startDir;
 
+        while (currentDir !== path.dirname(currentDir)) {
+            const packageJsonPath = path.resolve(currentDir, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                return currentDir;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+    } catch (error) {}
     return null;
 }

packages/core/src/subsystems/Security/Vault.service/connectors/JSONFileVault.class.ts

@@ -51,12 +51,12 @@ export class JSONFileVault extends VaultConnector {
         const relativeSearchLocations = ['vault.json', 'vault/vault.json', '.sre/vault.json'];
         found = findValidResourcePath(relativeSearchLocations, (dir, success, nextDir) => {
             if (!success) {
-                logger.warn('Vault file not found in:', nextDir);
+                logger.warn('Vault file not found in:', dir);
             }
         });
 
         if (found) {
-            logger.warn('Using alternative vault file found in : ', found);
+            logger.warn('Found a Vault file in : ', found, ' I will use this one.');
             return found;
         }
 

packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@smythos/sdk",
-    "version": "1.2.7",
+    "version": "1.3.0",
     "description": "SRE SDK",
     "keywords": [
         "smythos",

packages/sdk/src/Agent/Agent.class.ts

@@ -294,6 +294,8 @@ export class Agent extends SDKObject {
         connections: [],
     };
 
+    private _modes: TAgentMode[] = [];
+
     public get behavior() {
         return this._data.behavior;
     }
@@ -302,6 +304,10 @@ export class Agent extends SDKObject {
         this._data.behavior = behavior;
     }
 
+    public get modes() {
+        return this._modes;
+    }
+
     /**
      * The agent internal structure
      * used for by internal operations to generate the agent data
@@ -394,7 +400,7 @@ export class Agent extends SDKObject {
         DummyAccountHelper.addAgentToTeam(this._data.id, this._data.teamId);
 
         if (mode) {
-            this.addMode(mode);
+            this.setMode(mode);
         }
     }
 
@@ -676,6 +682,25 @@ export class Agent extends SDKObject {
         return component;
     }
 
+    /**
+     * Remove a skill from the agent.
+     *
+     * @param skillName - The name of the skill to remove
+     * @returns The removed skill
+     *
+     * @example
+     * ```typescript
+     * agent.removeSkill('fetch_weather');
+     * ```
+     */
+    removeSkill(skillName: string) {
+        const component = this.structure.components.find((c) => c.data.endpoint === skillName);
+        if (component) {
+            this.structure.components = this.structure.components.filter((c) => c.data.endpoint !== skillName);
+            this.data.components = this.data.components.filter((c) => c.data.endpoint !== skillName);
+        }
+    }
+
     async call(skillName: string, ...args: (Record<string, any> | any)[]) {
         try {
             const _agentData = this.data;
@@ -804,7 +829,7 @@ export class Agent extends SDKObject {
         if (!chatOptions.model) {
             chatOptions.model = this._data.defaultModel;
         }
-        return new Chat(chatOptions, this.data, {
+        return new Chat(chatOptions, this, {
             agentId: this._data.id,
             baseUrl: chatOptions.baseUrl,
         });
@@ -845,15 +870,33 @@ export class Agent extends SDKObject {
      * @example
      * ```typescript
      * agent.setMode(TAgentMode.PLANNER);
-     * //or
-     * agent.addMode('planner');
      * ```
      *
      * @param mode - The mode to apply, currently only "planner" is supported
      */
-    public addMode(mode: TAgentMode) {
+    public setMode(mode: TAgentMode) {
         if (typeof AgentMode?.[mode]?.apply === 'function') {
             AgentMode[mode].apply(this);
+            this._modes.push(mode);
+        } else {
+            console.warn(`Mode ${mode} is not a valid mode, skipping...`);
+        }
+    }
+
+    /**
+     * Remove the operational mode of the agent.
+     *
+     * @example
+     * ```typescript
+     * agent.unsetMode(TAgentMode.PLANNER);
+     * ```
+     *
+     * @param mode - The mode to remove
+     */
+    public unsetMode(mode: TAgentMode) {
+        if (typeof AgentMode?.[mode]?.remove === 'function') {
+            AgentMode[mode].remove(this);
+            this._modes = this._modes.filter((m) => m !== mode);
         } else {
             console.warn(`Mode ${mode} is not a valid mode, skipping...`);
         }

packages/sdk/src/Agent/mode/Planner.mode.ts

@@ -223,4 +223,13 @@ export default class PlannerMode {
         //     },
         // });
     }
+
+    static remove(agent: Agent) {
+        agent.removeSkill('_sre_AddTasks');
+        agent.removeSkill('_sre_AddSubTasks');
+        agent.removeSkill('_sre_UpdateTasks');
+        agent.removeSkill('_sre_TasksCompleted');
+        agent.removeSkill('_sre_clearTasks');
+        agent.behavior = agent.behavior.replace(_planner_prompt, '');
+    }
 }

packages/sdk/src/LLM/Chat.class.ts

@@ -5,7 +5,7 @@ import { AgentData, ChatOptions, PromptOptions } from '../types/SDKTypes';
 import { SDKObject } from '../Core/SDKObject.class';
 import { StorageInstance } from '../Storage/StorageInstance.class';
 import { SDKLog } from '../utils/console.utils';
-
+import type { Agent, TAgentMode } from '../Agent/Agent.class';
 const console = SDKLog;
 
 class LocalChatStore extends SDKObject implements ILLMContextStore {
@@ -156,12 +156,13 @@ class ChatCommand {
 export class Chat extends SDKObject {
     private _id: string;
     public _conversation: Conversation;
+    private _curAgentModes: string = '';
 
     public get id() {
         return this._id;
     }
 
-    private _data: any = {
+    private _emptyData: any = {
         version: '1.0.0',
         name: 'Agent',
         behavior: '',
@@ -170,14 +171,17 @@ export class Chat extends SDKObject {
         defaultModel: '',
         id: uid(),
     };
+    private _data: any = {};
     public get agentData() {
         return this._data;
     }
-    constructor(options: ChatOptions & { candidate: AccessCandidate }, _data?: any, private _convOptions: any = {}) {
+    constructor(options: ChatOptions & { candidate: AccessCandidate }, private source?: Agent | Record<string, any>, private _convOptions: any = {}) {
         super();
 
+        const _data = source?.data || source || {};
+
         const _model = options.model || _data?.defaultModel || '';
-        this._data = { ...this._data, ..._data, defaultModel: _model };
+        this._data = { ...this._emptyData, ..._data, defaultModel: _model };
 
         this._id = options.id || uid();
         if (options.persist) {
@@ -203,6 +207,9 @@ export class Chat extends SDKObject {
             this._convOptions.maxOutputTokens = options.maxOutputTokens;
         }
 
+        if ((this.source as Agent)?.modes) {
+            this._curAgentModes = (this.source as Agent).modes.join('|');
+        }
         this._conversation = createConversation(this._data, this._convOptions);
     }
 
@@ -241,6 +248,18 @@ export class Chat extends SDKObject {
      * @returns ChatCommand that can be executed or streamed
      */
     prompt(prompt: string, options?: PromptOptions) {
+        if ((this.source as Agent)?.modes) {
+            const modes = (this.source as Agent).modes.join('|');
+            if (modes !== this._curAgentModes) {
+                //agent mode changed we need to recreate the conversation object
+                const _data = this.source.data || this.source;
+                const _model = this._data?.defaultModel || '';
+                this._data = { ...this._emptyData, ..._data, defaultModel: _model };
+
+                this._conversation = createConversation(this._data, this._convOptions);
+                this._curAgentModes = modes;
+            }
+        }
         return new ChatCommand(prompt, this, options);
     }
 }