@smythos/sre 1.5.42 → 1.5.44

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

@@ -27,11 +27,6 @@ export declare class GenAILLM extends Component {
                 min: number;
                 label: string;
             };
-            maxThinkingTokens: {
-                type: string;
-                min: number;
-                label: string;
-            };
             stopSequences: {
                 type: string;
                 max: number;
@@ -221,6 +216,28 @@ export declare class GenAILLM extends Component {
                 label: string;
                 allowEmpty: boolean;
             };
+            useReasoning: {
+                type: string;
+                description: string;
+                label: string;
+            };
+            verbosity: {
+                type: string;
+                valid: string[];
+                label: string;
+                allowEmpty: boolean;
+            };
+            reasoningEffort: {
+                type: string;
+                valid: string[];
+                description: string;
+                label: string;
+            };
+            maxThinkingTokens: {
+                type: string;
+                min: number;
+                label: string;
+            };
         };
         inputs: {
             Input: {

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

@@ -5,6 +5,7 @@ import { LLMConnector } from '../LLMConnector';
 type ChatCompletionCreateParams = {
     model: string;
     messages: any;
+    max_completion_tokens?: number;
     max_tokens?: number;
     temperature?: number;
     stop?: string[];
@@ -12,6 +13,7 @@ type ChatCompletionCreateParams = {
     tools?: any;
     tool_choice?: string;
     stream?: boolean;
+    reasoning_effort?: 'none' | 'default' | 'low' | 'medium' | 'high';
 };
 export declare class GroqConnector extends LLMConnector {
     name: string;
@@ -55,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;
@@ -124,7 +125,14 @@ export type TLLMParams = {
     fromDate?: string;
     toDate?: string;
     useReasoning?: boolean;
+    /**
+     * Controls the level of effort the model will put into reasoning
+     * For GPT-OSS models (20B, 120B): "low" | "medium" | "high"
+     * For Qwen 3 32B: "none" | "default"
+     */
+    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.42",
+  "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

@@ -36,11 +36,6 @@ export class GenAILLM extends Component {
                 min: 1,
                 label: 'Maximum Tokens',
             },
-            maxThinkingTokens: {
-                type: 'number',
-                min: 1,
-                label: 'Maximum Thinking Tokens',
-            },
             stopSequences: {
                 type: 'string',
                 max: 400,
@@ -236,6 +231,31 @@ export class GenAILLM extends Component {
                 allowEmpty: true,
             },
             // #endregion
+
+            // #region Reasoning
+            useReasoning: {
+                type: 'boolean',
+                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'],
+                description: 'Controls the level of effort the model will put into reasoning',
+                label: 'Reasoning Effort',
+            },
+            maxThinkingTokens: {
+                type: 'number',
+                min: 1,
+                label: 'Maximum Thinking Tokens',
+            },
+            // #endregion
         },
         inputs: {
             Input: {
@@ -269,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'),
@@ -306,8 +327,11 @@ export class GenAILLM extends Component {
             .label('To Date'),
         // #endregion
 
+        // #region Reasoning
         useReasoning: Joi.boolean().optional().label('Use Reasoning'),
-        maxThinkingTokens: Joi.number().min(1).label('Maximum Thinking Tokens'),
+        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
     });
     constructor() {
         super();

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]);
+}

package/src/helpers/Conversation.helper.ts

@@ -348,11 +348,13 @@ export class Conversation extends EventEmitter {
             //     console.log('Passthrough skiped content ', content);
             //     return;
             // }
-            const lastMessage = this._context?.messages?.[this._context?.messages?.length - 1];
-            //const skip = lastMessage?.content?.includes(passThroughtContinueMessage) && lastMessage?.__smyth_data__?.internal;
+            //const lastMessage = this._context?.messages?.[this._context?.messages?.length - 1];
+            //const skip = lastMessage?.__smyth_data__?.internal;
 
             //skip if the content is the last generated message after a passthrough content
-            //if (skip) return;
+            // if (skip) {
+            //     let s = true;
+            // }
             _content += content;
             this.emit(TLLMEvent.Content, content);
         });
@@ -494,8 +496,9 @@ export class Conversation extends EventEmitter {
                     //delete toolHeaders['x-passthrough'];
                 } else {
                     //this._context.addAssistantMessage(passThroughContent, message_id);
-                    llmMessage.content += '\n' + passThroughContent;
-                    this._context.addToolMessage(llmMessage, processedToolsData, message_id);
+
+                    //llmMessage.content += '\n' + passThroughContent;
+                    this._context.addToolMessage(llmMessage, processedToolsData, message_id, { passThrough: true });
 
                     //this._context.addAssistantMessage(passThroughContent, message_id, { passthrough: true });
                     //this should not be stored in the persistent conversation store