@smythos/sre 1.5.12 → 1.5.13

package/dist/types/helpers/Conversation.helper.d.ts

@@ -46,8 +46,8 @@ export declare class Conversation extends EventEmitter {
         agentVersion?: string;
     });
     get ready(): any;
-    prompt(message?: string, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<any>;
-    streamPrompt(message?: string, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<any>;
+    prompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<any>;
+    streamPrompt(message?: string | any, toolHeaders?: {}, concurrentToolCalls?: number, abortSignal?: AbortSignal): Promise<any>;
     private resolveToolEndpoint;
     private useTool;
     addTool(tool: {

package/dist/types/subsystems/IO/Storage.service/connectors/LocalStorage.class.d.ts

@@ -27,7 +27,7 @@ export declare class LocalStorage extends StorageConnector {
      * @param {string} resourceId - The key of the object to be read.
      * @returns {Promise<any>} - A promise that resolves with the object data.
      */
-    read(acRequest: AccessRequest, resourceId: string): Promise<string>;
+    read(acRequest: AccessRequest, resourceId: string): Promise<NonSharedBuffer>;
     getMetadata(acRequest: AccessRequest, resourceId: string): Promise<StorageMetadata | undefined>;
     setMetadata(acRequest: AccessRequest, resourceId: string, metadata: StorageMetadata): Promise<void>;
     /**

package/dist/types/subsystems/Security/Vault.service/connectors/JSONFileVault.class.d.ts

@@ -5,14 +5,14 @@ import { VaultConnector } from '../VaultConnector';
 export type JSONFileVaultConfig = {
     file?: string;
     fileKey?: string;
-    shared?: boolean;
+    shared?: string;
 };
 export declare class JSONFileVault extends VaultConnector {
     protected _settings: JSONFileVaultConfig;
     name: string;
     private vaultData;
     private index;
-    private sharedVault;
+    private shared;
     constructor(_settings: JSONFileVaultConfig);
     private findVaultFile;
     private getMasterKeyInteractive;

package/dist/types/utils/data.utils.d.ts

@@ -8,6 +8,7 @@ export declare const isBuffer: (data: any) => boolean;
 export declare const isBinaryMimeType: (mimetype: any) => boolean;
 export declare const isBinaryData: (data: any) => boolean;
 export declare function isUrl(str: string): boolean;
+export declare function isFile(str: string): boolean;
 export declare function isSmythFsUrl(str: string): boolean;
 export declare const isSmythFileObject: (data: any) => boolean;
 export declare const isBufferObject: (data: Record<string, any>) => boolean;

package/package.json

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

package/src/Core/SmythRuntime.class.ts

@@ -21,6 +21,9 @@ export class SmythRuntime {
     private defaultConfig: SREConfig = {
         Vault: {
             Connector: 'JSONFileVault',
+            Settings: {
+                shared: 'default', //default team shares its secrets with all other teams
+            },
         },
         Account: {
             Connector: 'DummyAccount',

package/src/helpers/BinaryInput.helper.ts

@@ -135,7 +135,7 @@ export class BinaryInput {
                 extension = extension || mime.getExtension(this.mimetype);
                 if (!this._name.endsWith(`.${extension}`)) this._name += `.${extension}`;
             } catch (error) {
-                console.error('Error loading binary data from url:', data.url);
+                console.error('Error loading binary data from url:', data.url, error);
             }
 
             //this._source = data.url;
@@ -194,15 +194,19 @@ export class BinaryInput {
             }
             const ext = mime.getExtension(this.mimetype);
             if (!this._name.endsWith(`.${ext}`)) this._name += `.${ext}`;
+            this._ready = true;
+            return;
         }
 
         if (data instanceof Blob) {
             this._source = Buffer.from(await data.arrayBuffer());
             this.size = data.size;
             this.mimetype = data.type;
+            this._ready = true;
+            return;
         }
 
-        this._ready = true;
+        
     }
 
     private async getUrlInfo(url) {
@@ -236,6 +240,9 @@ export class BinaryInput {
                 await SmythFS.Instance.write(this.url, this._source, candidate, undefined, ttl);
                 this._uploading = false;
             }
+            else {
+                this._uploading = false;
+            }
         } catch (error) {
             console.error('Error uploading binary data:', error);
             this._uploading = false;

package/src/helpers/Conversation.helper.ts

@@ -217,7 +217,7 @@ export class Conversation extends EventEmitter {
             model: instance._model,
         };
     })
-    public async prompt(message?: string, toolHeaders = {}, concurrentToolCalls = 4, abortSignal?: AbortSignal) {
+    public async prompt(message?: string|any, toolHeaders = {}, concurrentToolCalls = 4, abortSignal?: AbortSignal) {
         const result = await this.streamPrompt(message, toolHeaders, concurrentToolCalls, abortSignal);
         return result;
     }
@@ -232,7 +232,11 @@ export class Conversation extends EventEmitter {
             model: instance._model,
         };
     })
-    public async streamPrompt(message?: string, toolHeaders = {}, concurrentToolCalls = 4, abortSignal?: AbortSignal) {
+    public async streamPrompt(message?: string|any, toolHeaders = {}, concurrentToolCalls = 4, abortSignal?: AbortSignal) {
+        let options = typeof message === 'object' ? message : {message};
+        message = options?.message;
+        const files = options?.files;
+
         if (message) {
             //initial call, reset stop flag
 
@@ -287,6 +291,7 @@ export class Conversation extends EventEmitter {
         const eventEmitter: any = await llmInference
             .promptStream({
                 contextWindow,
+                files,
                 params: {
                     model: this.model,
                     toolsConfig: this._settings?.toolsStrategy ? this._settings.toolsStrategy(toolsConfig) : toolsConfig,

package/src/subsystems/IO/Storage.service/connectors/LocalStorage.class.ts

@@ -82,7 +82,7 @@ export class LocalStorage extends StorageConnector {
         try {
             const filePath = this.getStorageFilePath(acRequest.candidate.id, resourceId);
             if (!fs.existsSync(filePath)) return undefined;
-            const data = fs.readFileSync(filePath, 'utf-8');
+            const data = fs.readFileSync(filePath, null);
             return data;
         } catch (error) {
             console.error(`Error reading object from local storage`, error.name, error.message);
@@ -143,10 +143,10 @@ export class LocalStorage extends StorageConnector {
         }
         const accessCandidate = acRequest.candidate;
 
-        let amzACL = ACL.from(acl).addAccess(accessCandidate.role, accessCandidate.id, TAccessLevel.Owner).ACL;
+        let localACL = ACL.from(acl).addAccess(accessCandidate.role, accessCandidate.id, TAccessLevel.Owner).ACL;
         let fileMetadata = {
             ...metadata,
-            acl: amzACL,
+            acl: localACL,
         };
 
         //now we can write the file

package/src/subsystems/LLMManager/LLM.helper.ts

@@ -124,7 +124,7 @@ export class LLMHelper {
                 throw new Error('Please provide a valid image url!');
             }
 
-            const dimensions = imageSize(buffer);
+            const dimensions =  imageSize(buffer);
 
             return {
                 width: dimensions?.width || 0,

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

@@ -14,7 +14,7 @@ export class AccessCandidate implements IAccessCandidate {
 
     private _validateId(id: string) {
         if (/[^a-zA-Z0-9-]/.test(id))
-            throw new Error('Access Candidate ID can only contain alphanumeric characters and hyphens');
+            throw new Error(`Access Candidate ID can only contain alphanumeric characters and hyphens, invalid id: ${id}`);
         return id;
     }
 

package/src/subsystems/Security/Vault.service/connectors/JSONFileVault.class.ts

@@ -20,20 +20,20 @@ const console = Logger('JSONFileVault');
 export type JSONFileVaultConfig = {
     file?: string;
     fileKey?: string;
-    shared?: boolean;
+    shared?: string;
 };
 
-export class JSONFileVault extends VaultConnector {
+export class JSONFileVault extends VaultConnector { 
     public name: string = 'JSONFileVault';
     private vaultData: any;
     private index: any;
-    private sharedVault: boolean;
+    private shared: string;
 
     constructor(protected _settings: JSONFileVaultConfig) {
         super(_settings);
         //if (!SmythRuntime.Instance) throw new Error('SRE not initialized');
 
-        this.sharedVault = _settings.shared || false; //if config.shared, all keys are accessible to all teams, and they are set under the 'shared' teamId
+        this.shared = _settings.shared || ''; //if config.shared, all keys are accessible to all teams, and they are set under the 'shared' teamId
 
         let vaultFile = this.findVaultFile(_settings.file);
         this.vaultData = {};
@@ -124,14 +124,14 @@ export class JSONFileVault extends VaultConnector {
         const accountConnector = ConnectorService.getAccountConnector();
         const teamId = await accountConnector.getCandidateTeam(acRequest.candidate);
 
-        return this.vaultData?.[teamId]?.[keyId] || this.vaultData?.['shared']?.[keyId];
+        return this.vaultData?.[teamId]?.[keyId] || this.vaultData?.[this.shared]?.[keyId];
     }
 
     @SecureConnector.AccessControl
     protected async exists(acRequest: AccessRequest, keyId: string) {
         const accountConnector = ConnectorService.getAccountConnector();
         const teamId = await accountConnector.getCandidateTeam(acRequest.candidate);
-        return !!(this.vaultData?.[teamId]?.[keyId] || this.vaultData?.['shared']?.[keyId]);
+        return !!(this.vaultData?.[teamId]?.[keyId] || this.vaultData?.[this.shared]?.[keyId]);
     }
 
     @SecureConnector.AccessControl
@@ -146,7 +146,7 @@ export class JSONFileVault extends VaultConnector {
         const acl = new ACL();
 
         if (resourceId && typeof this.vaultData?.[teamId]?.[resourceId] !== 'string') {
-            if (this.sharedVault && typeof this.vaultData?.['shared']?.[resourceId] === 'string') {
+            if (this.shared && typeof this.vaultData?.[this.shared]?.[resourceId] === 'string') {
                 acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
             }
 
@@ -157,7 +157,7 @@ export class JSONFileVault extends VaultConnector {
             .addAccess(TAccessRole.Team, teamId, TAccessLevel.Read)
             .addAccess(TAccessRole.Team, teamId, TAccessLevel.Write);
 
-        if (this.sharedVault && typeof this.vaultData?.['shared']?.[resourceId] === 'string') {
+        if (this.shared && typeof this.vaultData?.[this.shared]?.[resourceId] === 'string') {
             acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
         }
 

package/src/utils/data.utils.ts

@@ -1,5 +1,6 @@
 import { Readable } from 'stream';
 import axios from 'axios';
+import * as fs from 'fs';
 
 import { identifyMimeTypeFromBase64DataUrl, isBase64FileUrl, isBase64, identifyMimetypeFromBase64, isBase64DataUrl } from './base64.utils';
 import { isBinaryFileSync } from 'isbinaryfile';
@@ -123,6 +124,63 @@ export function isUrl(str: string): boolean {
     return regex.test(str);
 }
 
+export function isFile(str: string): boolean {
+    // Check if string exists and length is within limit
+    if (!str || str.length >= 1000) {
+        return false;
+    }
+
+    // Validate path format for both Windows and Unix systems
+    if (!isValidPathFormat(str)) {
+        return false;
+    }
+
+    // Check if file exists using fs.stat
+    try {
+        const stats = fs.statSync(str);
+        return stats.isFile();
+    } catch (error) {
+        // File doesn't exist or permission denied
+        return false;
+    }
+}
+
+/**
+ * Validates if a string is in a valid file path format for both Windows and Unix systems
+ * Supports both absolute and relative paths
+ */
+function isValidPathFormat(path: string): boolean {
+    // Check for invalid characters that are not allowed in file paths
+    const invalidChars = /[\0<>"|?*]/;
+    if (invalidChars.test(path)) {
+        return false;
+    }
+
+    // Windows path patterns
+    const windowsAbsolute = /^[a-zA-Z]:[\\\/]/; // C:\ or C:/
+    const windowsUNC = /^\\\\[^\\]+\\[^\\]+/; // \\server\share
+    const windowsRelative = /^\.{1,2}[\\\/]/; // .\ or ..\ or ./ or ../
+    
+    // Unix path patterns
+    const unixAbsolute = /^\//; // /path/to/file
+    const unixHome = /^~[\/]/; // ~/path/to/file
+    const unixRelative = /^\.{1,2}\//; // ./ or ../
+    
+    // Relative paths without leading ./ or .\
+    const genericRelative = /^[^\\\/]/; // path/to/file or path\to\file
+
+    // Check if path matches any valid pattern
+    return (
+        windowsAbsolute.test(path) ||
+        windowsUNC.test(path) ||
+        windowsRelative.test(path) ||
+        unixAbsolute.test(path) ||
+        unixHome.test(path) ||
+        unixRelative.test(path) ||
+        genericRelative.test(path)
+    );
+}
+
 export function isSmythFsUrl(str: string): boolean {
     if (typeof str !== 'string') return false;
     const regex = /^smythfs:\/\/([^\s.]+\.[^\s]{2,})(:[0-9]{1,5})?(\/[^\s]*)?(\?[^\s]*)?$/i;