@smythos/sre 1.5.26 → 1.5.32

package/dist/types/Components/GenAILLM.class.d.ts

@@ -88,6 +88,139 @@ export declare class GenAILLM extends Component {
                 description: string;
                 label: string;
             };
+            useWebSearch: {
+                type: string;
+                description: string;
+                label: string;
+            };
+            webSearchContextSize: {
+                type: string;
+                valid: string[];
+                label: string;
+            };
+            webSearchCity: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            webSearchCountry: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            webSearchRegion: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            webSearchTimezone: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            useSearch: {
+                type: string;
+                description: string;
+                label: string;
+                allowEmpty: boolean;
+            };
+            searchMode: {
+                type: string;
+                valid: string[];
+                label: string;
+                allowEmpty: boolean;
+            };
+            returnCitations: {
+                type: string;
+                description: string;
+                label: string;
+                allowEmpty: boolean;
+            };
+            maxSearchResults: {
+                type: string;
+                min: number;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            searchDataSources: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            searchCountry: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            excludedWebsites: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            allowedWebsites: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            includedXHandles: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            excludedXHandles: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            postFavoriteCount: {
+                type: string;
+                min: number;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            postViewCount: {
+                type: string;
+                min: number;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            link: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            safeSearch: {
+                type: string;
+                description: string;
+                label: string;
+                allowEmpty: boolean;
+            };
+            fromDate: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
+            toDate: {
+                type: string;
+                max: number;
+                label: string;
+                allowEmpty: boolean;
+            };
         };
         inputs: {
             Input: {

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

@@ -4,12 +4,11 @@ import { IAgent } from '@sre/types/Agent.types';
 export declare const cachePrefix = "serverless_code";
 export declare const cacheTTL: number;
 export declare function getLambdaFunctionName(agentId: string, componentId: string): string;
-export declare function generateCodeHash(code_body: string, code_imports: string, codeInputs: string[]): string;
+export declare function generateCodeHash(code_body: string, codeInputs: string[]): string;
 export declare function getSanitizeCodeHash(code: string): string;
 export declare function getDeployedCodeHash(agentId: string, componentId: string): Promise<any>;
 export declare function setDeployedCodeHash(agentId: string, componentId: string, codeHash: string): Promise<void>;
-export declare function extractNpmImports(code: string): unknown[];
-export declare function generateLambdaCode(code_imports: string, code_body: string, input_variables: string[]): string;
+export declare function generateLambdaCode(code: string, parameters: string[]): string;
 export declare function zipCode(directory: string): Promise<unknown>;
 export declare function createOrUpdateLambdaFunction(functionName: any, zipFilePath: any, awsConfigs: any): Promise<void>;
 export declare function waitForRoleDeploymentStatus(roleName: any, client: any): Promise<boolean>;
@@ -38,3 +37,10 @@ export declare function reportUsage({ cost, agentId, teamId }: {
     agentId: string;
     teamId: string;
 }): void;
+export declare function validateAsyncMainFunction(code: string): {
+    isValid: boolean;
+    error?: string;
+    parameters?: string[];
+    dependencies?: string[];
+};
+export declare function generateCodeFromLegacyComponent(code_body: string, code_imports: string, codeInputs: string[]): string;

package/dist/types/index.d.ts

@@ -165,6 +165,7 @@ export * from './subsystems/LLMManager/LLM.service/connectors/Groq.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/OpenAI.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/Perplexity.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/VertexAI.class';
+export * from './subsystems/LLMManager/LLM.service/connectors/xAI';
 export * from './subsystems/LLMManager/ModelsProvider.service/connectors/JSONModelsProvider.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/LocalStorageCache.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/RAMCache.class';

package/dist/types/subsystems/LLMManager/LLM.service/connectors/xAI.d.ts

@@ -0,0 +1,121 @@
+import EventEmitter from 'events';
+import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, TLLMMessageRole, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+type ChatCompletionParams = {
+    model: string;
+    messages: any[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+    response_format?: {
+        type: string;
+    };
+    stream?: boolean;
+    stream_options?: {
+        include_usage: boolean;
+    };
+    tools?: any[];
+    tool_choice?: any;
+    search_parameters?: {
+        mode?: 'auto' | 'on' | 'off';
+        return_citations?: boolean;
+        max_search_results?: number;
+        sources?: Array<{
+            type: 'web' | 'x' | 'news' | 'rss';
+            country?: string;
+            excluded_websites?: string[];
+            allowed_websites?: string[];
+            safe_search?: boolean;
+            included_x_handles?: string[];
+            excluded_x_handles?: string[];
+            post_favorite_count?: number;
+            post_view_count?: number;
+            links?: string[];
+        }>;
+        from_date?: string;
+        to_date?: string;
+    };
+};
+type TUsage = {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    prompt_tokens_details?: {
+        text_tokens?: number;
+        audio_tokens?: number;
+        image_tokens?: number;
+        cached_tokens?: number;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+        audio_tokens?: number;
+        accepted_prediction_tokens?: number;
+        rejected_prediction_tokens?: number;
+    };
+    reasoning_tokens?: number;
+    num_sources_used?: number;
+};
+export declare class xAIConnector extends LLMConnector {
+    name: string;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<ChatCompletionParams>;
+    protected reportUsage(usage: TUsage, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_write: number;
+        input_tokens_cache_read: number;
+        reasoning_tokens: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): {
+        tools: any[];
+        tool_choice: string;
+    } | {
+        tools?: undefined;
+        tool_choice?: undefined;
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock;
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
+    getConsistentMessages(messages: any): {
+        role: TLLMMessageRole;
+        content?: string | {
+            text: string;
+        }[] | Array<import("@anthropic-ai/sdk/resources").TextBlockParam | import("@anthropic-ai/sdk/resources").ImageBlockParam | import("@anthropic-ai/sdk/resources").ToolUseBlockParam | import("@anthropic-ai/sdk/resources").ToolResultBlockParam>;
+        parts?: {
+            text?: string;
+            functionCall?: {
+                name: string;
+                args: string;
+            };
+            functionResponse?: {
+                name: string;
+                response: {
+                    name: string;
+                    content: string;
+                };
+            };
+        }[];
+        tool_calls?: ToolData[];
+    }[];
+}
+export {};

package/dist/types/subsystems/LLMManager/models.d.ts

@@ -2594,6 +2594,7 @@ export declare const models: {
         tokens: number;
         completionTokens: number;
         enabled: boolean;
+        hidden: boolean;
         keyOptions: {
             tokens: number;
             completionTokens: number;

package/dist/types/types/LLM.types.d.ts

@@ -74,6 +74,22 @@ export type TLLMParams = {
     webSearchCountry?: string;
     webSearchRegion?: string;
     webSearchTimezone?: string;
+    useSearch?: boolean;
+    searchMode?: 'auto' | 'on' | 'off';
+    returnCitations?: boolean;
+    maxSearchResults?: number;
+    searchDataSources?: string[];
+    searchCountry?: string;
+    excludedWebsites?: string[];
+    allowedWebsites?: string[];
+    includedXHandles?: string[];
+    excludedXHandles?: string[];
+    postFavoriteCount?: number;
+    postViewCount?: number;
+    rssLinks?: string;
+    safeSearch?: boolean;
+    fromDate?: string;
+    toDate?: string;
     useReasoning?: boolean;
     isUserKey?: boolean;
     capabilities?: {

package/package.json

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

package/src/Components/GenAILLM.class.ts

@@ -97,6 +97,145 @@ export class GenAILLM extends Component {
                 description: 'The maximum number of messages to use from this component context window (if useContextWindow is true)',
                 label: 'Maximum Context Window Length',
             },
+
+            // #region Web Search
+            useWebSearch: {
+                type: 'boolean',
+                description: 'If true, the component will use web search for additional context',
+                label: 'Use Web Search',
+            },
+            webSearchContextSize: {
+                type: 'string',
+                valid: ['high', 'medium', 'low'],
+                label: 'Web Search Context Size',
+            },
+            webSearchCity: {
+                type: 'string',
+                max: 100,
+                label: 'Web Search City',
+                allowEmpty: true,
+            },
+            webSearchCountry: {
+                type: 'string',
+                max: 2,
+                label: 'Web Search Country',
+                allowEmpty: true,
+            },
+            webSearchRegion: {
+                type: 'string',
+                max: 100,
+                label: 'Web Search Region',
+                allowEmpty: true,
+            },
+            webSearchTimezone: {
+                type: 'string',
+                max: 100,
+                label: 'Web Search Timezone',
+                allowEmpty: true,
+            },
+            // #endregion
+
+            // #region xAI Search
+            useSearch: {
+                type: 'boolean',
+                description: 'If true, the component will use xAI live search capabilities',
+                label: 'Use Search',
+                allowEmpty: true,
+            },
+            searchMode: {
+                type: 'string',
+                valid: ['auto', 'on', 'off'],
+                label: 'Search Mode',
+                allowEmpty: true,
+            },
+            returnCitations: {
+                type: 'boolean',
+                description: 'If true, include citations and sources in the response',
+                label: 'Return Citations',
+                allowEmpty: true,
+            },
+            maxSearchResults: {
+                type: 'number',
+                min: 1,
+                max: 50,
+                label: 'Max Search Results',
+                allowEmpty: true,
+            },
+            searchDataSources: {
+                type: 'array',
+                max: 4,
+                label: 'Search Data Sources',
+                allowEmpty: true,
+            },
+            searchCountry: {
+                type: 'string',
+                max: 2,
+                label: 'Search Country',
+                allowEmpty: true,
+            },
+            excludedWebsites: {
+                type: 'string',
+                max: 10000,
+                label: 'Excluded Websites',
+                allowEmpty: true,
+            },
+            allowedWebsites: {
+                type: 'string',
+                max: 10000,
+                label: 'Allowed Websites',
+                allowEmpty: true,
+            },
+            includedXHandles: {
+                type: 'string',
+                max: 1000,
+                label: 'Included X Handles',
+                allowEmpty: true,
+            },
+            excludedXHandles: {
+                type: 'string',
+                max: 1000,
+                label: 'Excluded X Handles',
+                allowEmpty: true,
+            },
+            postFavoriteCount: {
+                type: 'number',
+                min: 0,
+                max: 1000000000,
+                label: 'Post Favorite Count',
+                allowEmpty: true,
+            },
+            postViewCount: {
+                type: 'number',
+                min: 0,
+                max: 1000000000,
+                label: 'Post View Count',
+                allowEmpty: true,
+            },
+            link: {
+                type: 'string',
+                max: 5000,
+                label: 'RSS Link',
+                allowEmpty: true,
+            },
+            safeSearch: {
+                type: 'boolean',
+                description: 'If true, enable safe search filtering',
+                label: 'Safe Search',
+                allowEmpty: true,
+            },
+            fromDate: {
+                type: 'string',
+                max: 10,
+                label: 'From Date',
+                allowEmpty: true,
+            },
+            toDate: {
+                type: 'string',
+                max: 10,
+                label: 'To Date',
+                allowEmpty: true,
+            },
+            // #endregion
         },
         inputs: {
             Input: {
@@ -131,13 +270,40 @@ export class GenAILLM extends Component {
         useContextWindow: Joi.boolean().optional().label('Use Context Window'),
         maxContextWindowLength: Joi.number().optional().min(0).label('Maximum Context Window Length'),
 
-        // #region Search
-        useWebSearch: Joi.boolean().optional().label('Use Search'),
-        webSearchContextSize: Joi.string().valid('high', 'medium', 'low').optional().label('Search Content Size'),
-        webSearchCity: Joi.string().max(100).optional().allow('').label('Search City'),
-        webSearchCountry: Joi.string().max(100).optional().allow('').label('Search Country'),
-        webSearchRegion: Joi.string().max(100).optional().allow('').label('Search Region'),
-        webSearchTimezone: Joi.string().max(100).optional().allow('').label('Search Timezone'),
+        // #region Web Search
+        useWebSearch: Joi.boolean().optional().label('Use Web Search'),
+        webSearchContextSize: Joi.string().valid('high', 'medium', 'low').optional().label('Web Search Context Size'),
+        webSearchCity: Joi.string().max(100).optional().allow('').label('Web Search City'),
+        webSearchCountry: Joi.string().max(2).optional().allow('').label('Web Search Country'),
+        webSearchRegion: Joi.string().max(100).optional().allow('').label('Web Search Region'),
+        webSearchTimezone: Joi.string().max(100).optional().allow('').label('Web Search Timezone'),
+        // #endregion
+
+        // #region xAI Search
+        useSearch: Joi.boolean().optional().allow('').label('Use Search'),
+        searchMode: Joi.string().valid('auto', 'on', 'off').optional().allow('').label('Search Mode'),
+        returnCitations: Joi.boolean().optional().allow('').label('Return Citations'),
+        maxSearchResults: Joi.number().min(1).max(100).optional().allow('').label('Max Search Results'),
+        searchDataSources: Joi.array().items(Joi.string().valid('web', 'x', 'news', 'rss')).max(4).optional().allow('').label('Search Data Sources'),
+        searchCountry: Joi.string().length(2).optional().allow('').label('Search Country'),
+        excludedWebsites: Joi.string().max(10000).optional().allow('').label('Excluded Websites'),
+        allowedWebsites: Joi.string().max(10000).optional().allow('').label('Allowed Websites'),
+        includedXHandles: Joi.string().max(1000).optional().allow('').label('Included X Handles'),
+        excludedXHandles: Joi.string().max(1000).optional().allow('').label('Excluded X Handles'),
+        postFavoriteCount: Joi.number().min(0).max(1000000000).optional().allow('').label('Post Favorite Count'),
+        postViewCount: Joi.number().min(0).max(1000000000).optional().allow('').label('Post View Count'),
+        rssLinks: Joi.string().max(10000).optional().allow('').label('RSS Link'),
+        safeSearch: Joi.boolean().optional().allow('').label('Safe Search'),
+        fromDate: Joi.string()
+            .pattern(/^\d{4}-\d{2}-\d{2}$/)
+            .optional()
+            .allow('')
+            .label('From Date'),
+        toDate: Joi.string()
+            .pattern(/^\d{4}-\d{2}-\d{2}$/)
+            .optional()
+            .allow('')
+            .label('To Date'),
         // #endregion
 
         useReasoning: Joi.boolean().optional().label('Use Reasoning'),

package/src/Components/ServerlessCode.class.ts

@@ -3,13 +3,14 @@ import { Component } from './Component.class';
 import Joi from 'joi';
 import { ConnectorService } from '@sre/Core/ConnectorsService';
 import { AWSCredentials, AWSRegionConfig } from '@sre/types/AWS.types';
-import { calculateExecutionCost, getLambdaCredentials, reportUsage } from '@sre/helpers/AWSLambdaCode.helper';
+import { calculateExecutionCost, generateCodeFromLegacyComponent, getLambdaCredentials, reportUsage } from '@sre/helpers/AWSLambdaCode.helper';
 
 export class ServerlessCode extends Component {
 
     protected configSchema = Joi.object({
         code_imports: Joi.string().max(1000).allow('').label('Imports'),
         code_body: Joi.string().max(500000).allow('').label('Code'),
+        code: Joi.string().max(500000).allow('').label('Code').optional(),
         deploy_btn: Joi.string().max(500000).allow('').label('Deploy').optional(),
         accessKeyId: Joi.string().max(100).allow('').label('AWS Access Key ID').optional(),
         secretAccessKey: Joi.string().max(200).allow('').label('AWS Secret Access Key').optional(),
@@ -70,11 +71,14 @@ export class ServerlessCode extends Component {
                     secretAccessKey: codeCredentials.secretAccessKey,
                 })
             }
+            let code = config?.data?.code;
+            if (!code) {
+                code = generateCodeFromLegacyComponent(config.data.code_body, config.data.code_imports, Object.keys(codeInputs))
+            }
             // Deploy lambda function if it doesn't exist or the code hash is different
             await codeConnector.agent(agent.id)
                 .deploy(config.id, {
-                    code: config?.data?.code_body,
-                    dependencies: config?.data?.code_imports,
+                    code,
                     inputs: codeInputs,
                 }, {
                     runtime: 'nodejs',