@smythos/sre 1.5.16 → 1.5.20

package/src/helpers/AWSLambdaCode.helper.ts

@@ -0,0 +1,347 @@
+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 { GetRoleCommand, CreateRoleCommand, IAMClient, GetRoleCommandOutput, CreateRoleCommandOutput } from '@aws-sdk/client-iam';
+import fs from 'fs';
+import { AWSCredentials, AWSRegionConfig } from '@sre/types/AWS.types';
+export const cachePrefix = 'serverless_code';
+export const cacheTTL = 60 * 60 * 24 * 16; // 16 days
+
+export function getLambdaFunctionName(agentId: string, componentId: string) {
+    return `${agentId}-${componentId}`;
+}
+
+
+export function generateCodeHash(code_body: string, code_imports: string, codeInputs: string[]) {
+    const importsHash = getSanitizeCodeHash(code_imports);
+    const bodyHash = getSanitizeCodeHash(code_body);
+    const inputsHash = getSanitizeCodeHash(JSON.stringify(codeInputs));
+    return `imports-${importsHash}__body-${bodyHash}__inputs-${inputsHash}`;
+}
+
+export function getSanitizeCodeHash(code: string) {
+    let output = '';
+    let isSingleQuote = false;
+    let isDoubleQuote = false;
+    let isTemplateLiteral = false;
+    let isRegex = false;
+    let isComment = false;
+    let prevChar = '';
+
+    for (let i = 0; i < code.length; i++) {
+        let char = code[i];
+        let nextChar = code[i + 1];
+
+        // Toggle string flags
+        if (char === "'" && !isDoubleQuote && !isTemplateLiteral && prevChar !== '\\') isSingleQuote = !isSingleQuote;
+        if (char === '"' && !isSingleQuote && !isTemplateLiteral && prevChar !== '\\') isDoubleQuote = !isDoubleQuote;
+        if (char === '`' && !isSingleQuote && !isDoubleQuote && prevChar !== '\\') isTemplateLiteral = !isTemplateLiteral;
+
+        // Handle regex cases
+        if (char === '/' && nextChar === '/' && !isSingleQuote && !isDoubleQuote && !isTemplateLiteral && !isRegex) {
+            isComment = true; // Single-line comment
+        }
+        if (char === '/' && nextChar === '*' && !isSingleQuote && !isDoubleQuote && !isTemplateLiteral) {
+            isComment = true; // Multi-line comment start
+        }
+        if (char === '*' && nextChar === '/' && isComment) {
+            isComment = false; // Multi-line comment end
+            i++; // Skip ending slash
+            continue;
+        }
+        if (char === '\n' && isComment) {
+            isComment = false; // End single-line comment
+        }
+
+        if (!isComment) {
+            output += char;
+        }
+        prevChar = char;
+    }
+
+    return crypto.createHash('md5').update(output.replace(/\s+/g, ' ').trim()).digest('hex');
+}
+
+export async function getDeployedCodeHash(agentId: string, componentId: string) {
+    const redisCache = ConnectorService.getCacheConnector();
+    const cachedCodeHash = await redisCache.user(AccessCandidate.agent(agentId)).get(`${cachePrefix}_${agentId}-${componentId}`);
+    return cachedCodeHash;
+}
+
+export async function setDeployedCodeHash(agentId: string, componentId: string, codeHash: string) {
+    const redisCache = ConnectorService.getCacheConnector();
+    await redisCache
+        .user(AccessCandidate.agent(agentId))
+        .set(`${cachePrefix}_${agentId}-${componentId}`, codeHash, null, null, cacheTTL);
+}
+
+
+export function extractNpmImports(code: string) {
+    const importRegex = /import\s+(?:[\w*\s{},]*\s+from\s+)?['"]([^'"]+)['"]/g;
+    const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
+    const dynamicImportRegex = /import\(['"]([^'"]+)['"]\)/g;
+
+    let libraries = new Set();
+    let match;
+
+    // Function to extract the main package name
+    function extractPackageName(modulePath: string) {
+        if (modulePath.startsWith('@')) {
+            // Handle scoped packages (e.g., @babel/core)
+            return modulePath.split('/').slice(0, 2).join('/');
+        }
+        return modulePath.split('/')[0]; // Extract the first part (main package)
+    }
+    // Match static ESM imports
+    while ((match = importRegex.exec(code)) !== null) {
+        libraries.add(extractPackageName(match[1]));
+    }
+    // Match CommonJS require() calls
+    while ((match = requireRegex.exec(code)) !== null) {
+        libraries.add(extractPackageName(match[1]));
+    }
+    // Match dynamic import() calls
+    while ((match = dynamicImportRegex.exec(code)) !== null) {
+        libraries.add(extractPackageName(match[1]));
+    }
+
+    return Array.from(libraries);
+}
+
+
+export function generateLambdaCode(code_imports: string, code_body: string, input_variables: string[]) {
+    const lambdaCode = `${code_imports}\nexport const handler = async (event, context) => {
+      try {
+        context.callbackWaitsForEmptyEventLoop = false;
+        let startTime = Date.now();
+        const result = await (async () => {
+          ${input_variables && input_variables.length ? input_variables.map((variable) => `const ${variable} = event.${variable};`).join('\n') : ''}
+          ${code_body}
+        })();
+        let endTime = Date.now();
+        return {
+            result,
+            executionTime: endTime - startTime
+        }
+      } catch (e) {
+        throw e;
+      }
+    };`;
+    return lambdaCode;
+}
+
+export async function zipCode(directory: string) {
+    return new Promise((resolve, reject) => {
+        zl.archiveFolder(directory, `${directory}.zip`).then(
+            function () {
+                resolve(`${directory}.zip`);
+            },
+            function (err) {
+                reject(err);
+            },
+        );
+    });
+}
+
+export async function createOrUpdateLambdaFunction(functionName, zipFilePath, awsConfigs) {
+    const client = new LambdaClient({
+        region: awsConfigs.region,
+        credentials: {
+            accessKeyId: awsConfigs.accessKeyId,
+            secretAccessKey: awsConfigs.secretAccessKey,
+        },
+    });
+    const functionContent = fs.readFileSync(zipFilePath);
+
+    try {
+        // Check if the function exists
+        const exisitingFunction = await getDeployedFunction(functionName, awsConfigs);
+        if (exisitingFunction) {
+            if (exisitingFunction.status === 'InProgress') {
+                await verifyFunctionDeploymentStatus(functionName, client);
+            }
+            // Update function code if it exists
+            const updateCodeParams = {
+                FunctionName: functionName,
+                ZipFile: functionContent,
+            };
+            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!');
+        } else {
+            // Create function if it does not exist
+            let roleArn = '';
+            // check if the role exists
+            try {
+                const iamClient = new IAMClient({
+                    region: awsConfigs.region,
+                    credentials: { accessKeyId: awsConfigs.accessKeyId, secretAccessKey: awsConfigs.secretAccessKey },
+                });
+                const getRoleCommand = new GetRoleCommand({ RoleName: `smyth-${functionName}-role` });
+                const roleResponse: GetRoleCommandOutput = await iamClient.send(getRoleCommand);
+                roleArn = roleResponse.Role.Arn;
+            } catch (error) {
+                if (error.name === 'NoSuchEntityException') {
+                    // create role
+                    const iamClient = new IAMClient({
+                        region: awsConfigs.region,
+                        credentials: { accessKeyId: awsConfigs.accessKeyId, secretAccessKey: awsConfigs.secretAccessKey },
+                    });
+                    const createRoleCommand = new CreateRoleCommand({
+                        RoleName: `smyth-${functionName}-role`,
+                        AssumeRolePolicyDocument: getLambdaRolePolicy(),
+                    });
+                    const roleResponse: CreateRoleCommandOutput = await iamClient.send(createRoleCommand);
+                    await waitForRoleDeploymentStatus(`smyth-${functionName}-role`, iamClient);
+                    roleArn = roleResponse.Role.Arn;
+                } else {
+                    throw error;
+                }
+            }
+
+            const functionParams = {
+                Code: { ZipFile: functionContent },
+                FunctionName: functionName,
+                Handler: 'index.handler',
+                Role: roleArn,
+                Runtime: Runtime.nodejs18x,
+                Layers: [],
+                Timeout: 900,
+                Tags: {
+                    'auto-delete': 'true',
+                },
+                MemorySize: 256,
+            };
+
+            const functionCreateCommand = new CreateFunctionCommand(functionParams);
+            const functionResponse = await client.send(functionCreateCommand);
+            // console.log('Function ARN:', functionResponse.FunctionArn);
+            await verifyFunctionDeploymentStatus(functionName, client);
+        }
+    } catch (error) {
+        throw error;
+    }
+}
+
+export async function waitForRoleDeploymentStatus(roleName, client): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+        try {
+            let interval = setInterval(async () => {
+                const getRoleCommand = new GetRoleCommand({ RoleName: roleName });
+                const roleResponse = await client.send(getRoleCommand);
+                if (roleResponse.Role.AssumeRolePolicyDocument) {
+                    clearInterval(interval);
+                    return resolve(true);
+                }
+            }, 7000);
+        } catch (error) {
+            return false;
+        }
+    });
+}
+
+export async function verifyFunctionDeploymentStatus(functionName, client): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+        try {
+            let interval = setInterval(async () => {
+                const getFunctionCommand = new GetFunctionCommand({ FunctionName: functionName });
+                const lambdaResponse = await client.send(getFunctionCommand);
+
+                if (lambdaResponse.Configuration.LastUpdateStatus === 'Successful') {
+                    clearInterval(interval);
+                    return resolve(true);
+                }
+            }, 5000);
+        } catch (error) {
+            return false;
+        }
+    });
+}
+
+export function getLambdaRolePolicy() {
+    return JSON.stringify({
+        Version: '2012-10-17',
+        Statement: [
+            {
+                Effect: 'Allow',
+                Principal: {
+                    Service: 'lambda.amazonaws.com',
+                },
+                Action: 'sts:AssumeRole',
+            },
+        ],
+    });
+}
+
+
+export async function updateDeployedCodeTTL(agentId: string, componentId: string, ttl: number) {
+    const redisCache = ConnectorService.getCacheConnector();
+    await redisCache.user(AccessCandidate.agent(agentId)).updateTTL(`${cachePrefix}_${agentId}-${componentId}`, ttl);
+}
+
+export async function invokeLambdaFunction(
+    functionName: string,
+    inputs: { [key: string]: any },
+    awsCredentials: AWSCredentials & AWSRegionConfig,
+): Promise<any> {
+    try {
+        const client = new LambdaClient({
+            region: awsCredentials.region as string,
+            ...(awsCredentials.accessKeyId && {
+                credentials: {
+                    accessKeyId: awsCredentials.accessKeyId as string,
+                    secretAccessKey: awsCredentials.secretAccessKey as string,
+                },
+            }),
+        });
+
+        const invokeCommand = new InvokeCommand({
+            FunctionName: functionName,
+            Payload: new TextEncoder().encode(`${JSON.stringify(inputs)}`),
+            InvocationType: 'RequestResponse',
+        });
+
+        const response: InvokeCommandOutput = await client.send(invokeCommand);
+        if (response.FunctionError) {
+            throw new Error(new TextDecoder().decode(response.Payload));
+        }
+        return new TextDecoder().decode(response.Payload);
+    } catch (error) {
+        throw error;
+    }
+}
+
+export async function getDeployedFunction(functionName: string, awsConfigs: AWSCredentials & AWSRegionConfig) {
+    try {
+        const client = new LambdaClient({
+            region: awsConfigs.region as string,
+            credentials: {
+                accessKeyId: awsConfigs.accessKeyId as string,
+                secretAccessKey: awsConfigs.secretAccessKey as string,
+            },
+        });
+        const getFunctionCommand = new GetFunctionCommand({ FunctionName: functionName });
+        const lambdaResponse: GetFunctionCommandOutput = await client.send(getFunctionCommand);
+        return {
+            status: lambdaResponse.Configuration.LastUpdateStatus,
+            functionName: lambdaResponse.Configuration.FunctionName,
+            functionVersion: lambdaResponse.Configuration.Version,
+            updatedAt: lambdaResponse.Configuration.LastModified,
+            role: lambdaResponse.Configuration.Role,
+            runtime: lambdaResponse.Configuration.Runtime,
+            version: lambdaResponse.Configuration.Version,
+        };
+    } catch (error) {
+        return null;
+    }
+}
+
+export function extractKeyFromTemplateVar(input: string) {
+    const regex = /\{\{KEY\((.*?)\)\}\}/;
+    const match = input.match(regex);
+    return match ? match[1] : input;
+}

package/src/helpers/Conversation.helper.ts

@@ -13,10 +13,8 @@ import { JSONContent } from './JsonContent.helper';
 import { OpenAPIParser } from './OpenApiParser.helper';
 import { Match, TemplateString } from './TemplateString.helper';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { delay } from '@sre/utils/date-time.utils';
 import { EventSource, FetchLike } from 'eventsource';
 import { hookAsyncWithContext } from '@sre/Core/HookService';
-import { DEFAULT_TEAM_ID } from '@sre/types/ACL.types';
 import { randomUUID } from 'crypto';
 import * as acorn from 'acorn';
 
@@ -159,7 +157,7 @@ export class Conversation extends EventEmitter {
                         this._spec = spec;
 
                         if (!this._agentId && _settings?.agentId) this._agentId = _settings.agentId;
-                        if (!this._agentId) this._agentId = 'FAKE_AGENT_ID'; //We use a fake agent ID to avoid ACL check errors
+                        if (!this._agentId) this._agentId = 'FAKE-AGENT-ID'; //We use a fake agent ID to avoid ACL check errors
 
                         // teamId is required to load custom LLMs, we must assign it before updateModel()
                         await this.assignTeamIdFromAgentId(this._agentId);
@@ -217,8 +215,19 @@ export class Conversation extends EventEmitter {
             model: instance._model,
         };
     })
-    public async prompt(message?: string|any, toolHeaders = {}, concurrentToolCalls = 4, abortSignal?: AbortSignal) {
+    public async prompt(message?: string | any, toolHeaders = {}, concurrentToolCalls = 4, abortSignal?: AbortSignal) {
+        // if an error occured while streaming, we need to propagate it so for this, we register a one time error listener
+        let error = null;
+        const errListener = (err) => (error = err);
+        this.once('error', errListener);
         const result = await this.streamPrompt(message, toolHeaders, concurrentToolCalls, abortSignal);
+
+        // if an error event occured, throw the error
+        if (error) {
+            throw error;
+        }
+
+        this.removeListener('error', errListener);
         return result;
     }
 
@@ -232,8 +241,8 @@ export class Conversation extends EventEmitter {
             model: instance._model,
         };
     })
-    public async streamPrompt(message?: string|any, toolHeaders = {}, concurrentToolCalls = 4, abortSignal?: AbortSignal) {
-        let options = typeof message === 'object' ? message : {message};
+    public async streamPrompt(message?: string | any, toolHeaders = {}, concurrentToolCalls = 4, abortSignal?: AbortSignal) {
+        let options = typeof message === 'object' ? message : { message };
         message = options?.message;
         const files = options?.files;
 

package/src/helpers/Sysconfig.helper.ts

@@ -5,6 +5,12 @@ import os from 'os';
 export function findSmythPath(_path: string = '', callback?: (smythDir: string, success?: boolean, nextDir?: string) => void) {
     //TODO : also search for a local sre configuration file indicating .smyth folder explicitly
 
+    let _smythDir = '';
+
+    if (_path) {
+        _smythDir = findSmythPath('');
+    }
+
     const searchDirectories = [];
 
     // 1. Try to find in local directory (the directory from which the program was run)
@@ -49,7 +55,11 @@ export function findSmythPath(_path: string = '', callback?: (smythDir: string,
         return dir;
     }
 
-    return localDir;
+    if (_smythDir && _path) {
+        return path.resolve(_smythDir, _path);
+    }
+
+    return homeDir;
 }
 
 function findPackageRoot(startDir = process.cwd()) {

package/src/index.ts

@@ -40,6 +40,7 @@ export * from './Components/LogicXOR.class';
 export * from './Components/MCPClient.class';
 export * from './Components/PromptGenerator.class';
 export * from './Components/ScrapflyWebScrape.class';
+export * from './Components/ServerlessCode.class';
 export * from './Components/TavilyWebSearch.class';
 export * from './Core/AgentProcess.helper';
 export * from './Core/boot';
@@ -49,6 +50,7 @@ export * from './Core/DummyConnector';
 export * from './Core/HookService';
 export * from './Core/SmythRuntime.class';
 export * from './Core/SystemEvents';
+export * from './helpers/AWSLambdaCode.helper';
 export * from './helpers/BinaryInput.helper';
 export * from './helpers/Conversation.helper';
 export * from './helpers/JsonContent.helper';

package/src/index.ts.bak

@@ -40,6 +40,7 @@ export * from './Components/LogicXOR.class';
 export * from './Components/MCPClient.class';
 export * from './Components/PromptGenerator.class';
 export * from './Components/ScrapflyWebScrape.class';
+export * from './Components/ServerlessCode.class';
 export * from './Components/TavilyWebSearch.class';
 export * from './Core/AgentProcess.helper';
 export * from './Core/boot';
@@ -49,6 +50,7 @@ export * from './Core/DummyConnector';
 export * from './Core/HookService';
 export * from './Core/SmythRuntime.class';
 export * from './Core/SystemEvents';
+export * from './helpers/AWSLambdaCode.helper';
 export * from './helpers/BinaryInput.helper';
 export * from './helpers/Conversation.helper';
 export * from './helpers/JsonContent.helper';

package/src/subsystems/AgentManager/ForkedAgent.class.ts

@@ -31,6 +31,7 @@ export class ForkedAgent {
         const data: any = fork(this.parent.data, componentId);
         data.variables = JSON.parse(JSON.stringify(this.parent?.data?.variables || {})); //copy parent Agent variables to forked agent
         data.teamId = this.parent.teamId;
+        data.planInfo = this.parent.data?.planInfo || {};
         //TODO : we need to create a default APIEndpoint bound to the root component if root component is not an APIEndpoint
         const content = { name: this.parent.name, data, teamId: this.parent.teamId, debugSessionEnabled: false, version: this.parent.version };
 

package/src/subsystems/ComputeManager/Code.service/CodeConnector.ts

@@ -16,7 +16,6 @@ export interface CodeConfig {
     timeout?: number; // Execution timeout in milliseconds
     memoryLimit?: number; // Memory allocation in MB
     environment?: Record<string, string>; // Environment variables
-
     // Platform-specific settings
     platformConfig?: Record<string, any>;
 }
@@ -38,61 +37,61 @@ export interface CodePreparationResult {
 
 export interface CodeDeployment {
     id: string; // Deployment identifier
-    status: 'deploying' | 'ready' | 'failed';
+    status: string;
     runtime: string;
     createdAt: Date;
     lastUsed?: Date;
+    lastUpdated?: Date;
 }
 
 export interface ICodeRequest {
     // Core workflow
-    prepare(input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
-    deploy(deploymentId: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
-    execute(input: CodeInput, config: CodeConfig): Promise<CodeExecutionResult>;
+    prepare(codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    deploy(codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    execute(codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
 
     // Execute with existing deployment (for platforms that support it)
-    executeDeployment(deploymentId: string, inputs: Record<string, any>): Promise<CodeExecutionResult>;
+    executeDeployment(codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
 
     // Deployment management
-    listDeployments(): Promise<CodeDeployment[]>;
-    getDeployment(deploymentId: string): Promise<CodeDeployment | null>;
-    deleteDeployment(deploymentId: string): Promise<void>;
+    listDeployments(codeUID: string, config: CodeConfig): Promise<CodeDeployment[]>;
+    getDeployment(codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null>;
+    deleteDeployment(codeUID: string, deploymentId: string, config: CodeConfig): Promise<void>;
 }
 
 export abstract class CodeConnector extends SecureConnector {
     public abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
-
     // Abstract methods that concrete connectors must implement
-    protected abstract prepare(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
-    protected abstract deploy(acRequest: AccessRequest, deploymentId: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
-    protected abstract execute(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodeExecutionResult>;
-    protected abstract executeDeployment(acRequest: AccessRequest, deploymentId: string, inputs: Record<string, any>): Promise<CodeExecutionResult>;
-    protected abstract listDeployments(acRequest: AccessRequest): Promise<CodeDeployment[]>;
-    protected abstract getDeployment(acRequest: AccessRequest, deploymentId: string): Promise<CodeDeployment | null>;
-    protected abstract deleteDeployment(acRequest: AccessRequest, deploymentId: string): Promise<void>;
+    protected abstract prepare(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    protected abstract deploy(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    protected abstract execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
+    protected abstract executeDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult>;
+    protected abstract listDeployments(acRequest: AccessRequest, codeUID: string, config: CodeConfig): Promise<CodeDeployment[]>;
+    protected abstract getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null>;
+    protected abstract deleteDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<void>;
 
     public requester(candidate: AccessCandidate): ICodeRequest {
         return {
-            prepare: async (input: CodeInput, config: CodeConfig) => {
-                return await this.prepare(candidate.readRequest, input, config);
+            prepare: async (codeUID: string, input: CodeInput, config: CodeConfig) => {
+                return await this.prepare(candidate.readRequest, codeUID, input, config);
             },
-            deploy: async (deploymentId: string, input: CodeInput, config: CodeConfig) => {
-                return await this.deploy(candidate.writeRequest, deploymentId, input, config);
+            deploy: async (codeUID: string, input: CodeInput, config: CodeConfig) => {
+                return await this.deploy(candidate.writeRequest, codeUID, input, config);
             },
-            execute: async (input: CodeInput, config: CodeConfig) => {
-                return await this.execute(candidate.readRequest, input, config);
+            execute: async (codeUID: string, inputs: Record<string, any>, config: CodeConfig) => {
+                return await this.execute(candidate.readRequest, codeUID, inputs, config);
             },
-            executeDeployment: async (deploymentId: string, inputs: Record<string, any>) => {
-                return await this.executeDeployment(candidate.readRequest, deploymentId, inputs);
+            executeDeployment: async (codeUID: string, deploymentId: string, inputs: Record<string, any>, config: CodeConfig) => {
+                return await this.executeDeployment(candidate.readRequest, codeUID, deploymentId, inputs, config);
             },
-            listDeployments: async () => {
-                return await this.listDeployments(candidate.readRequest);
+            listDeployments: async (codeUID: string, config: CodeConfig) => {
+                return await this.listDeployments(candidate.readRequest, codeUID, config);
             },
-            getDeployment: async (deploymentId: string) => {
-                return await this.getDeployment(candidate.readRequest, deploymentId);
+            getDeployment: async (codeUID: string, deploymentId: string, config: CodeConfig) => {
+                return await this.getDeployment(candidate.readRequest, codeUID, deploymentId, config);
             },
-            deleteDeployment: async (deploymentId: string) => {
-                await this.deleteDeployment(candidate.writeRequest, deploymentId);
+            deleteDeployment: async (codeUID: string, deploymentId: string, config: CodeConfig) => {
+                await this.deleteDeployment(candidate.writeRequest, codeUID, deploymentId, config);
             },
         } as ICodeRequest;
     }