@smythos/sre 1.5.43 → 1.5.44

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

@@ -221,6 +221,12 @@ export declare class GenAILLM extends Component {
                 description: string;
                 label: string;
             };
+            verbosity: {
+                type: string;
+                valid: string[];
+                label: string;
+                allowEmpty: boolean;
+            };
             reasoningEffort: {
                 type: string;
                 valid: string[];

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

@@ -4,13 +4,13 @@ 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, codeInputs: string[]): string;
-export declare function getSanitizeCodeHash(code: string): string;
+export declare function generateCodeHash(code_body: string, codeInputs: string[], envVariables: string[]): string;
+export declare function getSanitizeCodeHash(rawCode: 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 generateLambdaCode(code: string, parameters: string[]): string;
+export declare function generateLambdaCode(code: string, parameters: string[], envVariables: Record<string, 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 createOrUpdateLambdaFunction(functionName: any, zipFilePath: any, awsConfigs: any, envVariables: Record<string, string>): Promise<void>;
 export declare function waitForRoleDeploymentStatus(roleName: any, client: any): Promise<boolean>;
 export declare function verifyFunctionDeploymentStatus(functionName: any, client: any): Promise<boolean>;
 export declare function getLambdaRolePolicy(): string;
@@ -37,10 +37,13 @@ export declare function reportUsage({ cost, agentId, teamId }: {
     agentId: string;
     teamId: string;
 }): void;
-export declare function validateAsyncMainFunction(code: string): {
+export declare function validateAsyncMainFunction(rawCode: string): {
     isValid: boolean;
     error?: string;
     parameters?: string[];
     dependencies?: string[];
 };
 export declare function generateCodeFromLegacyComponent(code_body: string, code_imports: string, codeInputs: string[]): string;
+export declare function extractAllKeyNamesFromTemplateVars(input: string): string[];
+export declare function getCurrentEnvironmentVariables(agentTeamId: string, code: string): Promise<Record<string, string>>;
+export declare function getSortedObjectValues(obj: Record<string, string>): string[];

package/dist/types/index.d.ts

@@ -187,3 +187,4 @@ export * from './subsystems/Security/Vault.service/connectors/SecretsManager.cla
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/OpenAIConnector.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/types';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/constants';
+export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/utils';

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

@@ -57,4 +57,9 @@ export declare class GroqConnector extends LLMConnector {
     };
     getConsistentMessages(messages: TLLMMessageBlock[]): TLLMMessageBlock[];
 }
+/**
+ * Type guard to check if a value is a valid OpenAI reasoning effort.
+ * Uses array includes for better maintainability when OpenAI adds new values.
+ */
+export declare function isValidGroqReasoningEffort(value: unknown): value is 'low' | 'medium' | 'high' | 'none' | 'default';
 export {};

package/dist/types/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ChatCompletionsApiInterface.d.ts

@@ -21,10 +21,6 @@ export declare class ChatCompletionsApiInterface extends OpenAIApiInterface {
     createStream(body: OpenAI.ChatCompletionCreateParams, context: ILLMRequestContext): Promise<AsyncIterable<OpenAI.ChatCompletionChunk>>;
     handleStream(stream: AsyncIterable<OpenAI.ChatCompletionChunk>, context: ILLMRequestContext): EventEmitter;
     prepareRequestBody(params: TLLMPreparedParams): Promise<OpenAI.ChatCompletionCreateParams>;
-    /**
-     * Type guard to check if a tool is an OpenAI tool definition
-     */
-    private isOpenAIToolDefinition;
     /**
      * Transform OpenAI tool definitions to ChatCompletionTool format
      */

package/dist/types/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ResponsesApiInterface.d.ts

@@ -46,10 +46,6 @@ export declare class ResponsesApiInterface extends OpenAIApiInterface {
      */
     private calculateSearchToolUsage;
     prepareRequestBody(params: TLLMPreparedParams): Promise<OpenAI.Responses.ResponseCreateParams>;
-    /**
-     * Type guard to check if a tool is an OpenAI tool definition
-     */
-    private isOpenAIToolDefinition;
     /**
      * Transform OpenAI tool definitions to Responses.Tool format
      */

package/dist/types/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/utils.d.ts

@@ -0,0 +1,6 @@
+import OpenAI from 'openai';
+/**
+ * Type guard to check if a value is a valid OpenAI reasoning effort.
+ * Uses array includes for better maintainability when OpenAI adds new values.
+ */
+export declare function isValidOpenAIReasoningEffort(value: unknown): value is OpenAI.Responses.ResponseCreateParams['reasoning']['effort'];

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

@@ -35,6 +35,7 @@ export interface BedrockCredentials {
 export type ILLMConnectorCredentials = BasicCredentials | BedrockCredentials | VertexAICredentials;
 export type TOpenAIResponseToolChoice = OpenAI.Responses.ToolChoiceOptions | OpenAI.Responses.ToolChoiceTypes | OpenAI.Responses.ToolChoiceFunction;
 export type TLLMToolChoice = OpenAI.ChatCompletionToolChoiceOption;
+export type OpenAIReasoningEffort = NonNullable<OpenAI.Responses.ResponseCreateParams['reasoning']>['effort'];
 export type TOpenAIToolsInfo = {
     webSearch: {
         enabled: boolean;
@@ -129,8 +130,9 @@ export type TLLMParams = {
      * For GPT-OSS models (20B, 120B): "low" | "medium" | "high"
      * For Qwen 3 32B: "none" | "default"
      */
-    reasoningEffort?: 'none' | 'default' | 'low' | 'medium' | 'high';
+    reasoningEffort?: 'none' | 'default' | OpenAIReasoningEffort;
     max_output_tokens?: number;
+    verbosity?: OpenAI.Responses.ResponseCreateParams['text']['verbosity'];
     abortSignal?: AbortSignal;
 };
 export type TLLMPreparedParams = TLLMParams & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.5.43",
+  "version": "1.5.44",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",
@@ -19,6 +19,9 @@
     "CHANGELOG"
   ],
   "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@rollup/plugin-commonjs": "^28.0.3",
@@ -79,7 +82,7 @@
     "mime": "^4.0.3",
     "mysql2": "^3.11.3",
     "oauth-1.0a": "^2.2.6",
-    "openai": "^4.103.0",
+    "openai": "^5.12.2",
     "p-limit": "^6.1.0",
     "qs": "^6.13.0",
     "readline-sync": "^1.4.10",

package/src/Components/GenAILLM.class.ts

@@ -238,6 +238,12 @@ export class GenAILLM extends Component {
                 description: 'If true, the component will use reasoning capabilities for complex problem-solving',
                 label: 'Use Reasoning',
             },
+            verbosity: {
+                type: 'string',
+                valid: ['low', 'medium', 'high'],
+                label: 'Verbosity',
+                allowEmpty: true,
+            },
             reasoningEffort: {
                 type: 'string',
                 valid: ['none', 'default', 'low', 'medium', 'high'],
@@ -283,6 +289,7 @@ export class GenAILLM extends Component {
         useSystemPrompt: Joi.boolean().optional().label('Use System Prompt'),
         useContextWindow: Joi.boolean().optional().label('Use Context Window'),
         maxContextWindowLength: Joi.number().optional().min(0).label('Maximum Context Window Length'),
+        verbosity: Joi.string().valid('low', 'medium', 'high').optional().allow('').allow(null).label('Verbosity'),
 
         // #region Web Search
         useWebSearch: Joi.boolean().optional().label('Use Web Search'),
@@ -322,7 +329,7 @@ export class GenAILLM extends Component {
 
         // #region Reasoning
         useReasoning: Joi.boolean().optional().label('Use Reasoning'),
-        reasoningEffort: Joi.string().valid('none', 'default', 'low', 'medium', 'high').optional().allow('').label('Reasoning Effort'),
+        reasoningEffort: Joi.string().valid('none', 'default', 'minimal', 'low', 'medium', 'high').optional().allow('').label('Reasoning Effort'),
         maxThinkingTokens: Joi.number().min(1).optional().label('Maximum Thinking Tokens'),
         // #endregion
     });

package/src/helpers/AWSLambdaCode.helper.ts

@@ -2,7 +2,7 @@ import crypto from 'crypto';
 import { ConnectorService } from '@sre/Core/ConnectorsService';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 import zl from 'zip-lib';
-import { InvokeCommand, Runtime, LambdaClient, UpdateFunctionCodeCommand, CreateFunctionCommand, GetFunctionCommand, GetFunctionCommandOutput, InvokeCommandOutput } from '@aws-sdk/client-lambda';
+import { InvokeCommand, Runtime, LambdaClient, UpdateFunctionCodeCommand, CreateFunctionCommand, GetFunctionCommand, GetFunctionCommandOutput, InvokeCommandOutput, UpdateFunctionConfigurationCommand } from '@aws-sdk/client-lambda';
 import { GetRoleCommand, CreateRoleCommand, IAMClient, GetRoleCommandOutput, CreateRoleCommandOutput } from '@aws-sdk/client-iam';
 import fs from 'fs';
 import { AWSConfig, AWSCredentials, AWSRegionConfig } from '@sre/types/AWS.types';
@@ -20,13 +20,15 @@ export function getLambdaFunctionName(agentId: string, componentId: string) {
 }
 
 
-export function generateCodeHash(code_body: string, codeInputs: string[]) {
+export function generateCodeHash(code_body: string, codeInputs: string[], envVariables: string[]) {
     const bodyHash = getSanitizeCodeHash(code_body);
     const inputsHash = getSanitizeCodeHash(JSON.stringify(codeInputs));
-    return `body-${bodyHash}__inputs-${inputsHash}`;
+    const envVariablesHash = getSanitizeCodeHash(JSON.stringify(envVariables));
+    return `body-${bodyHash}__inputs-${inputsHash}__env-${envVariablesHash}`;
 }
 
-export function getSanitizeCodeHash(code: string) {
+export function getSanitizeCodeHash(rawCode: string) {
+    const code = replaceVaultKeysTemplateVars(rawCode, {});
     let output = '';
     let isSingleQuote = false;
     let isDoubleQuote = false;
@@ -82,9 +84,15 @@ export async function setDeployedCodeHash(agentId: string, componentId: string,
         .set(`${cachePrefix}_${agentId}-${componentId}`, codeHash, null, null, cacheTTL);
 }
 
-export function generateLambdaCode(code: string, parameters: string[]) {
+function replaceVaultKeysTemplateVars(code: string, envVariables: Record<string, string>) {
+    const regex = /\{\{KEY\((.*?)\)\}\}/g;
+    return code.replaceAll(regex, (match, p1) => `process.env.${p1}`);
+}
+
+export function generateLambdaCode(code: string, parameters: string[], envVariables: Record<string, string>) {
+    const codeWithEnvVariables = envVariables && Object.keys(envVariables).length ? replaceVaultKeysTemplateVars(code, envVariables) : code;
     const lambdaCode = `
-    ${code}
+    ${codeWithEnvVariables}
     export const handler = async (event, context) => {
       try {
         context.callbackWaitsForEmptyEventLoop = false;
@@ -118,7 +126,7 @@ export async function zipCode(directory: string) {
     });
 }
 
-export async function createOrUpdateLambdaFunction(functionName, zipFilePath, awsConfigs) {
+export async function createOrUpdateLambdaFunction(functionName, zipFilePath, awsConfigs, envVariables: Record<string, string>) {
     const client = new LambdaClient({
         region: awsConfigs.region,
         credentials: {
@@ -142,9 +150,12 @@ export async function createOrUpdateLambdaFunction(functionName, zipFilePath, aw
             };
             const updateFunctionCodeCommand = new UpdateFunctionCodeCommand(updateCodeParams);
             await client.send(updateFunctionCodeCommand);
-            // Update function configuration to attach layer
             await verifyFunctionDeploymentStatus(functionName, client);
-            // console.log('Lambda function code and configuration updated successfully!');
+
+            if (envVariables && Object.keys(envVariables).length) {
+                await updateLambdaFunctionConfiguration(client, functionName, envVariables);
+                await verifyFunctionDeploymentStatus(functionName, client);
+            }
         } else {
             // Create function if it does not exist
             let roleArn = '';
@@ -188,6 +199,7 @@ export async function createOrUpdateLambdaFunction(functionName, zipFilePath, aw
                     'auto-delete': 'true',
                 },
                 MemorySize: 256,
+                ...(envVariables && Object.keys(envVariables).length ? { Environment: { Variables: envVariables } } : {}),
             };
 
             const functionCreateCommand = new CreateFunctionCommand(functionParams);
@@ -200,6 +212,17 @@ export async function createOrUpdateLambdaFunction(functionName, zipFilePath, aw
     }
 }
 
+function updateLambdaFunctionConfiguration(client: LambdaClient, functionName: string, envVariables: Record<string, string>) {
+    const updateFunctionConfigurationParams = {
+        FunctionName: functionName,
+        Environment: {
+            Variables: envVariables,
+        },
+    };
+    const updateFunctionConfigurationCommand = new UpdateFunctionConfigurationCommand(updateFunctionConfigurationParams);
+    return client.send(updateFunctionConfigurationCommand);
+}
+
 export async function waitForRoleDeploymentStatus(roleName, client): Promise<boolean> {
     return new Promise((resolve, reject) => {
         try {
@@ -356,10 +379,11 @@ export function reportUsage({ cost, agentId, teamId }: { cost: number; agentId:
     });
 }
 
-export function validateAsyncMainFunction(code: string): { isValid: boolean; error?: string; parameters?: string[]; dependencies?: string[] } {
+export function validateAsyncMainFunction(rawCode: string): { isValid: boolean; error?: string; parameters?: string[]; dependencies?: string[] } {
     try {
-        // Parse the code using acorn
-        const ast = acorn.parse(code, { 
+        const code = replaceVaultKeysTemplateVars(rawCode, {});
+        // Parse the code using     acorn
+        const ast = acorn.parse(code, {
             ecmaVersion: 'latest',
             sourceType: 'module'
         });
@@ -387,8 +411,8 @@ export function validateAsyncMainFunction(code: string): { isValid: boolean; err
             }
 
             // Handle CallExpression (require() calls)
-            if (node.type === 'CallExpression' && 
-                node.callee.type === 'Identifier' && 
+            if (node.type === 'CallExpression' &&
+                node.callee.type === 'Identifier' &&
                 node.callee.name === 'require' &&
                 node.arguments.length > 0 &&
                 node.arguments[0].type === 'Literal') {
@@ -399,7 +423,7 @@ export function validateAsyncMainFunction(code: string): { isValid: boolean; err
             }
 
             // Handle dynamic import() calls
-            if (node.type === 'CallExpression' && 
+            if (node.type === 'CallExpression' &&
                 node.callee.type === 'Import' &&
                 node.arguments.length > 0 &&
                 node.arguments[0].type === 'Literal') {
@@ -473,16 +497,16 @@ export function validateAsyncMainFunction(code: string): { isValid: boolean; err
         }
 
         if (!hasMain) {
-            return { 
-                isValid: false, 
+            return {
+                isValid: false,
                 error: 'No main function found at root level',
                 dependencies
             };
         }
 
         if (!hasAsyncMain) {
-            return { 
-                isValid: false, 
+            return {
+                isValid: false,
                 error: 'Main function exists but is not async',
                 dependencies
             };
@@ -490,9 +514,9 @@ export function validateAsyncMainFunction(code: string): { isValid: boolean; err
 
         return { isValid: true, parameters: mainParameters, dependencies };
     } catch (error) {
-        return { 
-            isValid: false, 
-            error: `Failed to parse code: ${error.message}` 
+        return {
+            isValid: false,
+            error: `Failed to parse code: ${error.message}`
         };
     }
 }
@@ -526,3 +550,39 @@ export function generateCodeFromLegacyComponent(code_body: string, code_imports:
     return code;
 }
 
+export function extractAllKeyNamesFromTemplateVars(input: string): string[] {
+    const regex = /\{\{KEY\((.*?)\)\}\}/g;
+    const matches = [];
+    let match;
+    while ((match = regex.exec(input)) !== null) {
+        if (match[1]) {
+            matches.push(match[1]);
+        }
+    }
+    return matches;
+}
+
+
+async function fetchVaultSecret(keyName: string, agentTeamId: string): Promise<{ value: string, key: string }> {
+    const vaultSecret = await VaultHelper.getAgentKey(keyName, agentTeamId);
+    return {
+        value: vaultSecret,
+        key: keyName,
+    };
+
+}
+
+export async function getCurrentEnvironmentVariables(agentTeamId: string, code: string): Promise<Record<string, string>> {
+    const allKeyNames = extractAllKeyNamesFromTemplateVars(code);
+    const envVariables: Record<string, string> = {};
+    const vaultSecrets = await Promise.all(allKeyNames.map((keyName) => fetchVaultSecret(keyName, agentTeamId)));
+    vaultSecrets.forEach((secret) => {
+        envVariables[secret.key] = secret.value;
+    });
+    return envVariables;
+}
+
+export function getSortedObjectValues(obj: Record<string, string>): string[] {
+    const sortedKeys = Object.keys(obj).sort();
+    return sortedKeys.map((key) => obj[key]);
+}