@smythos/sre 1.6.14 → 1.7.5

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/Classifier.class.ts

@@ -115,7 +115,13 @@ ${JSON.stringify(categories, null, 2)}`;
 
         try {
             let response = await llmInference
-                .prompt({ query: prompt, params: { ...config, agentId: agent.id } })
+                .prompt({
+                    query: prompt,
+                    params: { ...config, agentId: agent.id },
+                    onFallback: (data) => {
+                        logger.debug(`\n ↩️ Using Fallback Model: ${data.model}`);
+                    },
+                })
                 .catch((error) => ({ error: error }));
 
             if (response?.error) {
@@ -146,7 +152,7 @@ ${JSON.stringify(categories, null, 2)}`;
                 delete parsed.error;
             }
 
-            logger.log(' Classifier result\n', parsed);
+            logger.debug('\n Classifier result\n', parsed);
 
             parsed['_debug'] = logger.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/GenAILLM.class.ts

@@ -7,6 +7,7 @@ import { getMimeType } from '@sre/utils/data.utils';
 import { Component } from './Component.class';
 import { formatDataForDebug } from '@sre/utils/data.utils';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { TLLMEvent } from '@sre/types/LLM.types';
 
 //TODO : better handling of context window exceeding max length
 
@@ -480,13 +481,16 @@ export class GenAILLM extends Component {
                             ...config.data,
                             agentId: agent.id,
                         },
+                        onFallback: (fallbackInfo) => {
+                            logger.debug(`\n ↩️ Using fallback model: ${fallbackInfo.model}`);
+                        },
                     })
                     .catch((error) => {
                         console.error('Error on promptStream: ', error);
                         reject(error);
                     });
 
-                eventEmitter.on('content', (content) => {
+                eventEmitter.on(TLLMEvent.Content, (content) => {
                     if (passThrough) {
                         if (typeof agent.callback === 'function') {
                             agent.callback({ content });
@@ -496,7 +500,7 @@ export class GenAILLM extends Component {
                     _content += content;
                 });
 
-                eventEmitter.on('thinking', (thinking) => {
+                eventEmitter.on(TLLMEvent.Thinking, (thinking) => {
                     if (passThrough) {
                         if (typeof agent.callback === 'function') {
                             agent.callback({ thinking });
@@ -504,7 +508,7 @@ export class GenAILLM extends Component {
                         agent.sse.send('llm/passthrough/thinking', thinking.replace(/\n/g, '\\n'));
                     }
                 });
-                eventEmitter.on('end', () => {
+                eventEmitter.on(TLLMEvent.End, () => {
                     if (passThrough) {
                         if (typeof agent.callback === 'function') {
                             agent.callback({ content: '\n' });
@@ -513,18 +517,18 @@ export class GenAILLM extends Component {
                     }
                     resolve(_content);
                 });
-                eventEmitter.on('interrupted', (reason) => {
+                eventEmitter.on(TLLMEvent.Interrupted, (reason) => {
                     finishReason = reason || 'stop';
                 });
 
-                eventEmitter.on('error', (error) => {
+                eventEmitter.on(TLLMEvent.Error, (error) => {
                     reject(error);
                 });
             });
             response = await contentPromise.catch((error) => {
                 return { error: error.message || error };
             });
-            // // If the model stopped before completing the response, this is usually due to output token limit reached.
+            // If the model stopped before completing the response, this is usually due to output token limit reached.
             if (finishReason !== 'stop') {
                 return {
                     Reply: response,
@@ -551,7 +555,7 @@ export class GenAILLM extends Component {
                 return { _error: Reply.error, _debug: logger.output };
             }
 
-            logger.debug(' Reply \n', Reply);
+            logger.debug('\n Reply \n', Reply);
 
             const result = { Reply };
 

package/src/Components/LLMAssistant.class.ts

@@ -113,7 +113,7 @@ export class LLMAssistant extends Component {
             const conversationId = input.ConversationId;
 
             let behavior = TemplateString(config.data.behavior).parse(input).result;
-            logger.debug(`[Parsed Behavior] \n${behavior}\n\n`);
+            logger.debug(`[Parsed Behavior] \n${behavior}`);
 
             //#region get max tokens
             let maxTokens = 2048;
@@ -154,6 +154,9 @@ export class LLMAssistant extends Component {
                         .promptStream({
                             contextWindow: messages,
                             params: { ...config, model, agentId: agent.id },
+                            onFallback: (fallbackInfo) => {
+                                logger.debug(`\n ↩️ Using fallback model: ${fallbackInfo.model}`);
+                            },
                         })
                         .catch((error) => {
                             console.error('Error on promptStream: ', error);
@@ -180,7 +183,13 @@ export class LLMAssistant extends Component {
                 response = await contentPromise;
             } else {
                 response = await llmInference
-                    .prompt({ contextWindow: messages, params: { ...config, agentId: agent.id } })
+                    .prompt({
+                        contextWindow: messages,
+                        params: { ...config, agentId: agent.id },
+                        onFallback: (fallbackInfo) => {
+                            logger.debug(`\n ↩️ Using fallback model: ${fallbackInfo.model}`);
+                        },
+                    })
                     .catch((error) => ({ error: error }));
             }
 
@@ -199,7 +208,7 @@ export class LLMAssistant extends Component {
             messages.push({ role: 'assistant', content: response });
             saveMessagesToSession(agent.id, userId, conversationId, messages, ttl);
 
-            logger.debug(' Response \n', response);
+            logger.debug('\n Response \n', response);
 
             const result = { Response: response };
 

package/src/Components/ScrapflyWebScrape.class.ts

@@ -53,7 +53,14 @@ export class ScrapflyWebScrape extends Component {
             logger.debug(`=== Web Scrape Log ===`);
             let Output: any = {};
             let _error = undefined;
-            const scrapeUrls = this.extractUrls(input);
+
+            // Filter inputs to include only the fields defined in the component's configuration.
+            // This prevents URLs from global variables from being scraped.
+            const componentInputNames = new Set(config.inputs.map((input) => input.name));
+            const filteredInput = Object.fromEntries(Object.entries(input).filter(([key]) => componentInputNames.has(key)));
+
+            const scrapeUrls = this.extractUrls(filteredInput);
+
             logger.debug('Payload:', JSON.stringify(config.data));
             logger.debug(`Vaild URLs: ${JSON.stringify(scrapeUrls)}`);
             const teamId = agent.teamId;

package/src/Components/TavilyWebSearch.class.ts

@@ -55,6 +55,9 @@ export class TavilyWebSearch extends Component {
             const api_key = await getCredentials(AccessCandidate.team(teamId), 'tavily');
 
             logger.debug('Payload:', JSON.stringify(config.data));
+
+            const excludeDomains = config.data.excludeDomains?.length ? config.data.excludeDomains.split(',').map((d) => d.trim()) : [];
+
             const response = await axios({
                 method: 'post',
                 url: 'https://api.tavily.com/search',
@@ -62,7 +65,7 @@ export class TavilyWebSearch extends Component {
                     api_key,
                     query: searchQuery,
                     topic: config.data.searchTopic,
-                    exclude_domains: config.data.excludeDomains?.length ? config.data.excludeDomains.split(',') : [],
+                    exclude_domains: excludeDomains,
                     max_results: config.data.sourcesLimit,
                     ...(config.data.timeRange !== 'None' ? { time_range: config.data.timeRange } : {}),
                     ...(config.data.includeImages ? { include_images: true } : {}),

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.