@smythos/sre 1.6.14 → 1.7.1

package/dist/types/types/SRE.types.d.ts

@@ -13,6 +13,7 @@ import { LogService } from '@sre/IO/Log.service';
 import { ComponentService } from '@sre/AgentManager/Component.service';
 import { ModelsProviderService } from '@sre/LLMManager/ModelsProvider.service';
 import { CodeService } from '@sre/ComputeManager/Code.service';
+import { SchedulerService } from '@sre/AgentManager/Scheduler.service';
 export type TServiceRegistry = {
     Storage?: StorageService;
     VectorDB?: VectorDBService;
@@ -29,6 +30,7 @@ export type TServiceRegistry = {
     Component?: ComponentService;
     ModelsProvider?: ModelsProviderService;
     Code?: CodeService;
+    Scheduler?: SchedulerService;
 };
 export declare enum TConnectorService {
     Storage = "Storage",
@@ -45,7 +47,8 @@ export declare enum TConnectorService {
     Log = "Log",
     Component = "Component",
     ModelsProvider = "ModelsProvider",
-    Code = "Code"
+    Code = "Code",
+    Scheduler = "Scheduler"
 }
 export type SREConnectorConfig = {
     Connector: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.6.14",
+  "version": "1.7.1",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",
@@ -31,6 +31,7 @@
     "@types/express": "^4.17.23",
     "@types/lodash": "^4.17.10",
     "@types/node": "^20.19.0",
+    "@types/ws": "^8.18.1",
     "cross-env": "^7.0.3",
     "ctix": "^2.7.1",
     "dependency-cruiser": "^16.3.3",
@@ -59,11 +60,12 @@
     "@pinecone-database/pinecone": "^3.0.0",
     "@runware/sdk-js": "^1.1.36",
     "@smithy/smithy-client": "^4.4.3",
-    "@zilliz/milvus2-sdk-node": "^2.5.11",
+    "@zilliz/milvus2-sdk-node": "^2.6.2",
     "acorn": "^8.14.1",
     "axios": "^1.7.2",
     "chokidar": "^4.0.3",
     "dayjs": "^1.11.11",
+    "domutils": "^3.2.2",
     "dotenv": "^16.4.5",
     "eventsource": "^3.0.2",
     "express": "^4.21.2",
@@ -71,6 +73,7 @@
     "form-data": "^4.0.3",
     "gpt-tokenizer": "^2.2.1",
     "groq-sdk": "^0.6.1",
+    "htmlparser2": "^10.0.0",
     "image-size": "^1.1.1",
     "ioredis": "^5.4.1",
     "isbinaryfile": "^5.0.2",
@@ -90,6 +93,7 @@
     "socks-proxy-agent": "^8.0.4",
     "winston": "^3.13.0",
     "winston-transport": "^4.7.0",
+    "ws": "^8.18.3",
     "xxhashjs": "^0.2.2",
     "zip-lib": "^1.1.2"
   },

package/src/Components/APICall/OAuth.helper.ts

@@ -7,8 +7,9 @@ import axios, { AxiosRequestConfig } from 'axios';
 import { Logger } from '@sre/helpers/Log.helper';
 import { ConnectorService } from '@sre/Core/ConnectorsService';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { Match, TemplateString } from '@sre/helpers/TemplateString.helper';
 import { SystemEvents } from '@sre/Core/SystemEvents';
+import { cloneDeep } from 'lodash';
 
 const console = Logger('OAuth.helper');
 let managedVault: any;
@@ -49,11 +50,9 @@ export function extractAdditionalParamsForOAuth1(reqConfig: AxiosRequestConfig =
 
     // Headers might be an object or array of objects
     if (Array.isArray(headers)) {
-        const contentTypeHeader = headers.find(h =>
-            Object.keys(h).some(k => k.toLowerCase() === 'content-type')
-        );
+        const contentTypeHeader = headers.find((h) => Object.keys(h).some((k) => k.toLowerCase() === 'content-type'));
         if (contentTypeHeader) {
-            const key = Object.keys(contentTypeHeader).find(k => k.toLowerCase() === 'content-type');
+            const key = Object.keys(contentTypeHeader).find((k) => k.toLowerCase() === 'content-type');
             contentType = contentTypeHeader[key];
         }
     } else {
@@ -83,9 +82,7 @@ export function extractAdditionalParamsForOAuth1(reqConfig: AxiosRequestConfig =
             console.debug('OAuth1: Including form parameters in signature:', Object.keys(formParams));
             additionalParams = { ...additionalParams, ...formParams };
         }
-    } else if (contentType.includes(REQUEST_CONTENT_TYPES.json) ||
-        contentType.includes('application/') ||
-        contentType.includes('text/')) {
+    } else if (contentType.includes(REQUEST_CONTENT_TYPES.json) || contentType.includes('application/') || contentType.includes('text/')) {
         // For JSON and other non-form data, use oauth_body_hash
         if (reqConfig.data && method !== 'GET' && method !== 'HEAD') {
             let bodyString = '';
@@ -110,8 +107,7 @@ export function extractAdditionalParamsForOAuth1(reqConfig: AxiosRequestConfig =
                 // Only include string values, exclude Files/Blobs
                 if (typeof value === 'string') {
                     additionalParams[key] = value;
-                } else if (typeof value === 'object' && value !== null &&
-                    ('size' in value || 'type' in value)) {
+                } else if (typeof value === 'object' && value !== null && ('size' in value || 'type' in value)) {
                     // Skip binary data (Files, Blobs, etc.)
                     continue;
                 } else {
@@ -123,8 +119,7 @@ export function extractAdditionalParamsForOAuth1(reqConfig: AxiosRequestConfig =
     } else if (!contentType && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
         // No content type specified but has data
         if (reqConfig.data) {
-            const bodyString = typeof reqConfig.data === 'string' ?
-                reqConfig.data : JSON.stringify(reqConfig.data);
+            const bodyString = typeof reqConfig.data === 'string' ? reqConfig.data : JSON.stringify(reqConfig.data);
             const hash = crypto.createHash('sha1').update(bodyString).digest('base64');
             additionalParams['oauth_body_hash'] = hash;
         }
@@ -165,9 +160,10 @@ export const buildOAuth1Header = (url, method, oauth1Credentials, additionalPara
         data: additionalParams, // Parameters should be in data field for oauth-1.0a library
     };
 
-    const token = oauth1Credentials.token && oauth1Credentials.token !== '' ?
-        { key: oauth1Credentials.token, secret: oauth1Credentials.tokenSecret || '' } :
-        null;
+    const token =
+        oauth1Credentials.token && oauth1Credentials.token !== ''
+            ? { key: oauth1Credentials.token, secret: oauth1Credentials.tokenSecret || '' }
+            : null;
 
     const signedRequest = oauth.authorize(requestData, token);
     return oauth.toHeader(signedRequest);
@@ -190,24 +186,25 @@ export const retrieveOAuthTokens = async (agent, config) => {
             // Check if it's new structure (has auth_data and auth_settings) or old structure
             const isNewStructure = tokensData.auth_data !== undefined && tokensData.auth_settings !== undefined;
 
+            //* Resolve vault keys inside auth_data
+            if (isNewStructure) {
+                await Promise.all(
+                    Object.keys(tokensData.auth_settings).map(async (key) => {
+                        if (typeof tokensData.auth_settings[key] !== 'string') return;
+                        tokensData.auth_settings[key] = await TemplateString(tokensData.auth_settings[key]).parseTeamKeysAsync(agent.teamId)
+                            .asyncResult;
+                    })
+                );
+            }
+
             // Extract tokens based on structure
-            const primaryToken = isNewStructure
-                ? tokensData.auth_data?.primary
-                : tokensData.primary;
-            const secondaryToken = isNewStructure
-                ? tokensData.auth_data?.secondary
-                : tokensData.secondary;
-            const expiresIn = isNewStructure
-                ? tokensData.auth_data?.expires_in
-                : tokensData.expires_in;
+            const primaryToken = isNewStructure ? tokensData.auth_data?.primary : tokensData.primary;
+            const secondaryToken = isNewStructure ? tokensData.auth_data?.secondary : tokensData.secondary;
+            const expiresIn = isNewStructure ? tokensData.auth_data?.expires_in : tokensData.expires_in;
 
             // Extract settings based on structure
-            const type = isNewStructure
-                ? tokensData.auth_settings?.type
-                : (tokensData.type || tokensData.oauth_info?.type);
-            const service = isNewStructure
-                ? tokensData.auth_settings?.service
-                : tokensData.oauth_info?.service;
+            const type = isNewStructure ? tokensData.auth_settings?.type : tokensData.type || tokensData.oauth_info?.type;
+            const service = isNewStructure ? tokensData.auth_settings?.service : tokensData.oauth_info?.service;
 
             // Add warning logs for OAuth2
             if (type === 'oauth2' && service !== 'oauth2_client_credentials') {
@@ -353,8 +350,6 @@ const getKeyIdsFromTemplateVars = (str: string): string[] => {
 };
 
 async function getClientCredentialToken(tokensData, logger, keyId, oauthTokens, config, agent, isNewStructure = false) {
-
-
     const logAndThrowError = (message) => {
         logger.debug(message);
         throw new Error(message);
@@ -399,7 +394,7 @@ async function getClientCredentialToken(tokensData, logger, keyId, oauthTokens,
                     auth_data: {
                         ...(tokensData?.auth_data || {}),
                         primary: newAccessToken,
-                        expires_in: expirationTimestamp.toString()
+                        expires_in: expirationTimestamp.toString(),
                     },
                     auth_settings: {
                         ...(tokensData?.auth_settings || {}),
@@ -416,7 +411,7 @@ async function getClientCredentialToken(tokensData, logger, keyId, oauthTokens,
                 updatedData = {
                     ...tokensData,
                     primary: newAccessToken,
-                    expires_in: expirationTimestamp.toString()
+                    expires_in: expirationTimestamp.toString(),
                 };
                 // Ensure required fields are present for old structure
                 if (!updatedData.type) updatedData.type = 'oauth2';
@@ -428,7 +423,7 @@ async function getClientCredentialToken(tokensData, logger, keyId, oauthTokens,
                         service: 'oauth2_client_credentials',
                         tokenURL,
                         clientID,
-                        clientSecret
+                        clientSecret,
                     };
                 }
             }

package/src/Components/APIEndpoint.class.ts

@@ -39,7 +39,7 @@ function parseKey(str: string = '', teamId: string): string {
 export class APIEndpoint extends Component {
     protected configSchema = Joi.object({
         endpoint: Joi.string()
-            .pattern(/^[a-zA-Z0-9]+([-_][a-zA-Z0-9]+)*$/)
+            .pattern(/^[a-zA-Z0-9_]+([-_][a-zA-Z0-9_]+)*$/)
             .max(50)
             .required(),
         method: Joi.string().valid('POST', 'GET').allow(''), //we're accepting empty value because we consider it POST by default.
@@ -57,13 +57,25 @@ export class APIEndpoint extends Component {
     async process(input, config, agent: Agent) {
         await super.process(input, config, agent);
 
+        if (typeof config.process === 'function') {
+            //special case, APIEndpoint has a custom process method.
+            //the inputs are not passed directly to APIEndpoints, we need to read them from the context.
+            const contextData = agent?.agentRuntime?.getComponentData(config.id);
+
+            const inputs = Array.isArray(contextData?.input) ? contextData?.input : [contextData?.input];
+
+            const result = await config.process.apply(null, inputs);
+            return result;
+        }
+
         const req: AgentRequest = agent.agentRequest;
         const logger = this.createComponentLogger(agent, config);
 
+        const isTrigger = req.path.startsWith(agent.triggerBasePath);
         const headers = req ? req.headers : {};
-        let body = req ? req.body : input; //handle debugger injection
-        const params = req ? req.params : {};
-        let query = req ? req.query : {};
+        let body = req && !isTrigger ? req.body : input; //handle debugger injection
+        const params = req && !isTrigger ? req.params : {};
+        let query = req && !isTrigger ? req.query : {};
         const _authInfo = req ? req._agent_authinfo : undefined;
 
         // parse template variables
@@ -87,7 +99,7 @@ export class APIEndpoint extends Component {
 
         // set default value and agent variables
         const inputsWithDefaultValue = config.inputs.filter(
-            (input) => input.defaultVal !== undefined && input.defaultVal !== '' && input.defaultVal !== null,
+            (input) => input.defaultVal !== undefined && input.defaultVal !== '' && input.defaultVal !== null
         );
 
         const bodyInputNames: string[] = [];
@@ -218,7 +230,7 @@ export class APIEndpoint extends Component {
                         return await binaryInput.getJsonData(AccessCandidate.agent(agent.id));
                     }
                     return null;
-                }),
+                })
             );
 
             // Filter out null values and handle single/multiple results
@@ -231,4 +243,11 @@ export class APIEndpoint extends Component {
 
         return { headers, body, query, params, _authInfo, _debug: logger.output };
     }
+
+    async postProcess(output, config, agent: Agent): Promise<any> {
+        if (typeof config.process === 'function') {
+            return output?.result;
+        }
+        return output;
+    }
 }

package/src/Components/Component.class.ts

@@ -144,4 +144,15 @@ export class Component {
     hasOutput(id, config, agent: Agent): any {
         return false;
     }
+
+    /**
+     * A generic registration function that can be overridden by child classes to register the trigger with providers
+     * this function is usually called outside of a workflow in order to register the trigger with providers
+     * @param componentId the id of the component to register (in SRE a single trigger instance handles all the triggers of the same type)
+     * @param agent the agent instance
+     * @param payload any additional payload to pass to the trigger
+     */
+    async register(componentId: string, componentSettings: any, payload?: any) {}
+
+    async unregister(componentId: string, componentSettings: any, payload?: any) {}
 }

package/src/Components/Triggers/Gmail.trigger.ts

@@ -0,0 +1,282 @@
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { ManagedOAuth2Credentials } from '@sre/Security/Credentials/ManagedOAuth2Credentials.class';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { findAll, innerText, isTag, removeElement } from 'domutils';
+import { parseDocument } from 'htmlparser2';
+import { Trigger } from './Trigger.class';
+export type GmailTriggerAttachment = {
+    filename: string;
+    mimeType: string;
+    size: number;
+    attachmentId: string;
+};
+export type GmailTriggerMessage = {
+    id: string;
+    threadId: string;
+    labelIds: string[];
+    snippet: string;
+    sizeEstimate: number;
+    internalDate: string;
+    headers: {
+        from: string;
+        to: string;
+        cc: string;
+        bcc: string;
+        subject: string;
+        date: string;
+        messageId: string;
+    };
+    body: {
+        text: string;
+        html: string;
+    };
+    attachments: GmailTriggerAttachment[];
+    isUnread: true;
+};
+export class GmailTrigger extends Trigger {
+    async collectPayload(input, config, agent: Agent) {
+        const credentialsKey = config?.data?.oauth_cred_id;
+        const agentCandidate = AccessCandidate.agent(agent.id);
+        const oauth2Credentials = await ManagedOAuth2Credentials.load(credentialsKey, agentCandidate);
+
+        console.log(
+            oauth2Credentials.accessToken,
+            oauth2Credentials.refreshToken,
+            oauth2Credentials.expiresIn,
+            oauth2Credentials.scope,
+            oauth2Credentials.tokenUrl,
+            oauth2Credentials.service
+        );
+
+        await oauth2Credentials.refreshAccessToken();
+
+        const messages = await getMostRecentUnreadMessage(0, oauth2Credentials, 5);
+        return messages;
+    }
+}
+
+/**
+ * Make an authenticated Gmail API request
+ */
+async function gmailApiRequest(endpoint, accessToken) {
+    const url = `https://www.googleapis.com/gmail/v1/users/me${endpoint}`;
+
+    try {
+        const result = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        const json = await result.json();
+        console.log(json);
+        return json;
+    } catch (error) {
+        throw new Error(`Gmail API request failed: ${error.message}`);
+    }
+}
+
+/**
+ * Get the most recent unread messages
+ */
+async function getMostRecentUnreadMessage(
+    retryCount = 0,
+    oauth2Credentials: ManagedOAuth2Credentials,
+    numMessages: number = 1,
+    excludeMessageId?: string
+) {
+    const MAX_RETRIES = 1; // Only retry once to prevent infinite loops
+
+    let accessToken = oauth2Credentials.accessToken;
+
+    // If no access token provided, or if requests fail, refresh it
+    if (!accessToken) {
+        accessToken = await oauth2Credentials.refreshAccessToken();
+    }
+
+    try {
+        console.log('Fetching unread messages...');
+
+        const collectedIds: string[] = [];
+        let pageToken: string | undefined = undefined;
+        let reachedBoundary = false;
+
+        while (collectedIds.length < numMessages && !reachedBoundary) {
+            const pageSize = Math.min(Math.max(numMessages, 1), 100);
+            const pageQuery = `/messages?q=is:unread&maxResults=${pageSize}${pageToken ? `&pageToken=${pageToken}` : ''}`;
+            const listResponse = await gmailApiRequest(pageQuery, accessToken);
+
+            const messages = Array.isArray(listResponse.messages) ? listResponse.messages : [];
+            if (messages.length === 0) {
+                break;
+            }
+
+            for (const m of messages) {
+                if (excludeMessageId && m.id === excludeMessageId) {
+                    reachedBoundary = true;
+                    break;
+                }
+                collectedIds.push(m.id);
+                if (collectedIds.length >= numMessages) {
+                    break;
+                }
+            }
+
+            if (collectedIds.length >= numMessages || reachedBoundary || !listResponse.nextPageToken) {
+                break;
+            }
+            pageToken = listResponse.nextPageToken;
+        }
+
+        if (collectedIds.length === 0) {
+            return [];
+        }
+
+        // Fetch full message details in parallel
+        const details = await Promise.all(collectedIds.map((id) => gmailApiRequest(`/messages/${id}?format=full`, accessToken)));
+        const parsed = details.map((d) => parseMessage(d));
+        return parsed;
+    } catch (error) {
+        // If token expired, try refreshing and retry once
+        if ((error.message.includes('401') || error.message.includes('unauthorized')) && retryCount < MAX_RETRIES) {
+            console.log('Access token expired, refreshing...');
+            try {
+                accessToken = await oauth2Credentials.refreshAccessToken();
+                return await getMostRecentUnreadMessage(retryCount + 1, oauth2Credentials, numMessages, excludeMessageId);
+            } catch (refreshError) {
+                throw new Error(`Authentication failed: ${refreshError.message}`);
+            }
+        }
+
+        throw error;
+    }
+}
+
+/**
+ * Parse Gmail message into structured format
+ */
+function parseMessage(message) {
+    const headers: any = {};
+    const payload = message.payload || {};
+
+    // Extract headers
+    if (payload.headers) {
+        payload.headers.forEach((header) => {
+            headers[header.name.toLowerCase()] = header.value;
+        });
+    }
+
+    // Extract body content
+    let textBody = '';
+    let htmlBody = '';
+
+    function extractBody(part) {
+        if (part.mimeType === 'text/plain' && part.body && part.body.data) {
+            textBody = Buffer.from(part.body.data, 'base64').toString('utf-8');
+        } else if (part.mimeType === 'text/html' && part.body && part.body.data) {
+            htmlBody = Buffer.from(part.body.data, 'base64').toString('utf-8');
+        }
+
+        if (part.parts) {
+            part.parts.forEach(extractBody);
+        }
+    }
+
+    if (payload.parts) {
+        payload.parts.forEach(extractBody);
+    } else if (payload.body && payload.body.data) {
+        // Single part message
+        if (payload.mimeType === 'text/plain') {
+            textBody = Buffer.from(payload.body.data, 'base64').toString('utf-8');
+        } else if (payload.mimeType === 'text/html') {
+            htmlBody = Buffer.from(payload.body.data, 'base64').toString('utf-8');
+        }
+    }
+
+    if (textBody && !htmlBody) {
+        htmlBody = textBody;
+    }
+
+    if (htmlBody && !textBody) {
+        textBody = htmlToPlainText(htmlBody);
+    }
+
+    // Get attachments info
+    const attachments = [];
+    function findAttachments(part) {
+        if (part.filename && part.filename.length > 0) {
+            attachments.push({
+                filename: part.filename,
+                mimeType: part.mimeType,
+                size: part.body ? part.body.size : 0,
+                attachmentId: part.body ? part.body.attachmentId : null,
+            });
+        }
+
+        if (part.parts) {
+            part.parts.forEach(findAttachments);
+        }
+    }
+
+    if (payload.parts) {
+        payload.parts.forEach(findAttachments);
+    }
+
+    return {
+        email: {
+            id: message.id,
+            threadId: message.threadId,
+            labelIds: message.labelIds || [],
+            snippet: message.snippet || '',
+            sizeEstimate: message.sizeEstimate || 0,
+            internalDate: message.internalDate ? new Date(parseInt(message.internalDate)).toISOString() : null,
+            headers: {
+                from: headers.from || '',
+                to: headers.to || '',
+                cc: headers.cc || '',
+                bcc: headers.bcc || '',
+                subject: headers.subject || '',
+                date: headers.date || '',
+                messageId: headers['message-id'] || '',
+            },
+            body: {
+                text: textBody,
+                html: htmlBody,
+            },
+            attachments: attachments,
+            isUnread: message.labelIds ? message.labelIds.includes('UNREAD') : false,
+        },
+    };
+}
+
+var populateChar = function (ch, amount) {
+    var result = '';
+    for (var i = 0; i < amount; i += 1) {
+        result += ch;
+    }
+    return result;
+};
+
+function htmlToPlainText(htmlText, _styleConfig?) {
+    try {
+        const document = parseDocument(String(htmlText));
+        const nodesToRemove = findAll((node) => isTag(node) && (node.name === 'script' || node.name === 'style'), document.children);
+        nodesToRemove.forEach((node) => removeElement(node));
+
+        let text = innerText(document);
+
+        text = text.replace(/\u00A0/g, ' ');
+        text = text.replace(/\r\n?/g, '\n');
+        text = text.replace(/\t+/g, ' ');
+        text = text.replace(/[ \t\f]+\n/g, '\n');
+        text = text.replace(/\n{3,}/g, '\n\n');
+        text = text.replace(/[ ]{2,}/g, ' ');
+        text = text.replace(/^\s+|\s+$/g, '');
+
+        if (text.length === 0 || text.lastIndexOf('\n') !== text.length - 1) {
+            text += '\n';
+        }
+        return text;
+    } catch (err) {
+        return String(htmlText);
+    }
+}

package/src/Components/Triggers/JobScheduler.trigger.ts

@@ -0,0 +1,45 @@
+import { IAgent as Agent, IAgent } from '@sre/types/Agent.types';
+import { Trigger } from './Trigger.class';
+import { AgentRequest } from '@sre/AgentManager/AgentRequest.class';
+import express from 'express';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { ISchedulerRequest } from '@sre/AgentManager/Scheduler.service/SchedulerConnector';
+import { Schedule } from '@sre/AgentManager/Scheduler.service/Schedule.class';
+import { Job } from '@sre/AgentManager/Scheduler.service/Job.class';
+import { JSONContent } from '@sre/helpers/JsonContent.helper';
+
+export class JobSchedulerTrigger extends Trigger {
+    async collectPayload(input, settings, agent: Agent) {
+        const req = agent.agentRequest;
+
+        let payload: any = JSONContent(settings?.data?.payload).tryParse();
+        if (typeof payload !== 'object') {
+            payload = {};
+        }
+
+        return [
+            {
+                ...payload,
+            },
+        ];
+    }
+
+    async register(componentId: string, componentSettings: any, payload?: { agentData: IAgent; triggerUrl: string }) {
+        try {
+            const agent: any = payload?.agentData;
+            const triggerName = componentSettings.triggerEndpoint;
+            const schedulerConnector = ConnectorService.getSchedulerConnector();
+            if (!schedulerConnector) {
+                throw new Error('Scheduler connector not found');
+            }
+
+            const schedulerRequester: ISchedulerRequest = schedulerConnector.agent(agent.id);
+            const jobId = `job-${agent.id}-${triggerName}`;
+            await schedulerRequester.add(jobId, new Job({ agentId: agent.id, type: 'trigger', triggerName }), Schedule.every('10s'));
+        } catch (error) {
+            throw new Error('Failed to schedule job');
+        }
+    }
+
+    async unregister(componentId: string, agent: Agent, payload?: any) {}
+}

package/src/Components/Triggers/README.md

@@ -0,0 +1,3 @@
+# Triggers System
+
+### !!!Work in progress!!! This is still a work in progress, the system is not yet fully implemented.