@smythos/sre 1.5.1 → 1.5.4

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

@@ -0,0 +1,559 @@
+import fs from 'fs';
+import path from 'path';
+import { Agent } from './Agent.class';
+import { Component } from '@sre/Components/Component.class';
+
+import { Logger } from '@sre/helpers/Log.helper';
+import { uid } from '@sre/utils';
+import { RuntimeContext } from '@sre/MemoryManager/RuntimeContext';
+import { LLMCache } from '@sre/MemoryManager/LLMCache';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+const console = Logger('AgentRuntime');
+const AgentRuntimeUnavailable = new Proxy(
+    {},
+    {
+        get: function (target, prop, receiver) {
+            // Check if the property being accessed is a function
+            if (typeof target[prop] === 'function') {
+                return target[prop];
+            } else {
+                // Return a function that logs "unavailable"
+                return function () {
+                    console.warn(`AgentRuntime Unavailable tried to call : ${prop.toString()}`);
+                };
+            }
+        },
+    },
+);
+export class AgentRuntime {
+    private static processResults: any = {};
+    private static tagsData = {};
+    public static dummy = AgentRuntimeUnavailable;
+
+    private agentContext: RuntimeContext;
+    public llmCache: LLMCache;
+    //private ctxFile: string = '';
+    private xDebugRun: string | undefined = '';
+    private xDebugInject: string | undefined = '';
+    private xDebugRead: string | undefined = '';
+    private xDebugStop: string | undefined = '';
+    private xDebugPendingInject: any = null;
+    private xMockDataInject: any = null;
+    public xDebugId: string | undefined = '';
+
+    private xDebugCmd: string | undefined = '';
+    private _debugActive = false;
+    private _runtimeFileReady = false;
+    public sessionClosed = false;
+
+    private reqTagOwner = false;
+
+    //reqTag is used to identify the current running workflow including nested calls, it allows us to identify circular calls
+    public reqTag: any;
+    public processID: any; //this identifies the current processID, a process ID is the full set of runCycles that is executed by the agent.
+    public workflowReqId: any; //this identifies the current running workflow. a workflow starts when and agent endpoint is called, or a debug session is initiated, and ends when no more steps can be executed.
+
+    public alwaysActiveComponents: any = {};
+    public exclusiveComponents: any = {};
+
+    private checkRuntimeContext: any = null;
+
+    public get circularLimitReached() {
+        return this.agentContext?.circularLimitReached || false;
+    }
+    public set circularLimitReached(value) {
+        if (this.agentContext) this.agentContext.circularLimitReached = value;
+    }
+
+    public get debug() {
+        return this._debugActive;
+    }
+    public get curStep() {
+        return this.agentContext?.step || 0;
+    }
+
+    constructor(public agent: Agent) {
+        this.reqTag = agent.agentRequest.header('X-REQUEST-TAG');
+        const isNestedProcess: boolean = !!this.reqTag;
+
+        if (!this.reqTag) {
+            //tagged request should not be run in debug mode, this comes from a parent agent
+            this.xDebugStop = agent.agentRequest.header('X-DEBUG-STOP');
+            this.xDebugRun = agent.agentRequest.header('X-DEBUG-RUN'); //send this as header to create a session and attach it
+            this.xDebugInject = agent.agentRequest.header('X-DEBUG-INJ');
+            this.xDebugRead = agent.agentRequest.header('X-DEBUG-READ');
+            this.reqTag = 'xTAG-' + uid(); //if request tag is not set, set a new value, this will be used to tag nested agent calls
+            this.reqTagOwner = true;
+        } else {
+            this.xDebugStop = undefined;
+            this.xDebugRun = undefined;
+            this.xDebugInject = undefined;
+            this.xDebugRead = undefined;
+        }
+
+        this.xDebugId = this.xDebugStop || this.xDebugRun || this.xDebugRead;
+
+        //if (req.body) {
+        if (!this.xDebugId && agent.agentRequest.body) {
+            if (this.xDebugInject != undefined && this.xDebugInject != null) {
+                this.xDebugPendingInject = agent.agentRequest.body;
+                this.xDebugRun = this.xDebugInject || 'inj-' + uid();
+            } else {
+                if (this.xDebugRun == '') {
+                    this.xDebugRun = 'dbg-' + uid(); //generate a random debug id
+                }
+            }
+            this.xDebugId = this.xDebugRun;
+        }
+
+        if (agent.agentRequest.header('X-MOCK-DATA-INJ') !== undefined) {
+            this.xMockDataInject = agent.agentRequest.body;
+        }
+
+        this.processID = this.xDebugId;
+
+        if (!this.xDebugId) {
+            //if it's not a debug session, processID is unique per request
+            this.xDebugId = agent.sessionId;
+            this.processID = this.reqTag;
+        }
+        if (isNestedProcess) {
+            // Need to make processID unique to run same sub-agents multiple times in parallel
+            this.processID += `:${Math.floor(1000 + Math.random() * 9000)}`;
+        }
+
+        //we need a way to identify current running workflow in a unique way
+        //=> In debug mode, xDebugRun holds the debug sessionID which is unique per workflow run
+        //   if the debug session is stopped, xDebugStop holds the sessionID
+        //   Note : We can't use reqTag in debug mode because it changes every time a new debug step is executed
+        //
+        //=> In normal mode, reqTag is unique per workflow run
+        this.workflowReqId = this.xDebugRun || this.xDebugStop || this.reqTag;
+
+        //tagsData can be updated from external integrations (eg. Chatbot, API Endpoint, etc.)
+        if (!AgentRuntime.tagsData[this.reqTag]) AgentRuntime.tagsData[this.reqTag] = {};
+        if (!AgentRuntime.processResults[this.processID])
+            AgentRuntime.processResults[this.processID] = {
+                timestamp: Date.now(),
+                errorResults: [],
+                sessionResults: [],
+            };
+
+        this.agentContext = new RuntimeContext(this);
+        this.agentContext.on('ready', () => {
+            this.alwaysActiveComponents = {};
+            this.exclusiveComponents = {};
+            for (let component of this.agent.data.components) {
+                const cpt: Component = this.agent.ComponentInstances[component.name];
+                if (!cpt) {
+                    console.warn(`Component ${component.name} Exists in agent but has no implementation`);
+                    continue;
+                }
+
+                if (cpt.alwaysActive) {
+                    this.alwaysActiveComponents[component.id] = cpt;
+                    this.updateComponent(component.id, { active: true, alwaysActive: true });
+                    const runtimeData = { ...this.getRuntimeData(component.id) };
+                    this.saveRuntimeComponentData(component.id, runtimeData);
+                }
+                if (cpt.exclusive) {
+                    this.exclusiveComponents[component.id] = cpt;
+                    this.updateComponent(component.id, { exclusive: true });
+                    const runtimeData = { ...this.getRuntimeData(component.id) };
+                    this.saveRuntimeComponentData(component.id, runtimeData);
+                }
+            }
+        });
+
+        //if xDebugId is equal to agent session, it means that the debugging features are not active
+        this._debugActive = this.xDebugId != agent.sessionId;
+
+        const xCacheId = agent.agentRequest.header('X-CACHE-ID') || '';
+        this.llmCache = new LLMCache(AccessCandidate.agent(this.agent.id), xCacheId);
+        //this.xCacheId =
+    }
+
+    public async ready() {
+        return this.agentContext.ready();
+    }
+
+    public destroy() {
+        this.sessionClosed = true;
+        this.sync();
+    }
+
+    public incTag(componentId) {
+        if (!AgentRuntime.tagsData[this.reqTag][componentId]) AgentRuntime.tagsData[this.reqTag][componentId] = 0;
+        AgentRuntime.tagsData[this.reqTag][componentId]++;
+
+        // console.log(
+        //     `incTag agentId=${this.agent.id} componentId=${componentId} tag=${this.reqTag} ==> ${AgentRuntime.tagsData[this.reqTag][componentId]}`,
+        // );
+        //console.log('incTag tagsData', tagsData);
+    }
+
+    public async sync() {
+        //if (!this.ctxFile) return;
+
+        const deleteTag = (this.reqTagOwner && this.sessionClosed) || this.circularLimitReached;
+        if (deleteTag) {
+            console.log('>>>>>>>>>>>> deleting tagsData', this.reqTag);
+            delete AgentRuntime.tagsData[this.reqTag];
+        }
+
+        this.agentContext.sync();
+    }
+    public getWaitingComponents() {
+        const ctxData = this.agentContext;
+        const dbgComponents: any = Object.values(ctxData?.components || []).filter((c: any) => c?.ctx?.active == true);
+        const waitingComponents: any = dbgComponents.filter((c: any) => c?.ctx?.status && typeof c?.ctx?.output !== undefined);
+        return waitingComponents;
+    }
+    public getExclusiveActiveComponents() {
+        const ctxData = this.agentContext;
+        const dbgComponents: any = Object.values(ctxData?.components || []).filter((c: any) => c?.ctx?.active == true);
+        const exclusiveActiveComponents: any = dbgComponents.filter((c: any) => c?.ctx?.exclusive == true);
+        return exclusiveActiveComponents;
+    }
+    public readState(stateId: string, deltaOnly = false) {
+        //if (!this._debugActive || !this.xDebugRead) return null;
+        if (!this._debugActive || !stateId) return null;
+
+        //this.checkRuntimeContext();
+        const runtime = this;
+        const agent = this.agent;
+
+        const ctxData = runtime.agentContext;
+        const dbgAllComponents: any = runtime.xDebugPendingInject || Object.values(ctxData?.components || []);
+
+        //first try to find exclusive active components
+        let dbgActiveComponents: any;
+        dbgActiveComponents = dbgAllComponents.filter((c: any) => c?.ctx?.active == true && c?.ctx?.exclusive == true);
+        //if no exclusive active components, find all active components
+        if (!dbgActiveComponents || dbgActiveComponents.length == 0)
+            dbgActiveComponents = dbgAllComponents.filter(
+                (c: any) =>
+                    c?.ctx?.active == true ||
+                    (!c?.ctx?.output?._error && Array.isArray(c?.ctx?._job_components) && c?.ctx?._job_components.length > 0),
+            );
+        //find waiting components that was not previously run
+        const dbgActiveWaitingComponents: any = dbgAllComponents.filter(
+            (c: any) => c?.ctx?.active == true && c?.ctx?.status && typeof c?.ctx?.output !== undefined,
+        );
+
+        const dbgActiveReadyComponents: any = dbgAllComponents.filter((c: any) => c?.ctx?.active == true && !c?.ctx?.status);
+
+        let state = {};
+        for (let dbgComponent of dbgAllComponents) {
+            state[dbgComponent.id] = dbgComponent.ctx;
+        }
+
+        //let dbgSession: any = runtime.xDebugRead;
+        let dbgSession: any = stateId;
+
+        // let alwaysActiveComponents = 0;
+        // for (let activeCpt of dbgActiveComponents) {
+        //     if (this.agent.alwaysActiveComponents[activeCpt.id]) alwaysActiveComponents++;
+        // }
+
+        if (!dbgActiveComponents || dbgActiveComponents.length == 0 /*|| dbgActiveComponents.length == alwaysActiveComponents*/) {
+            dbgSession = null;
+            runtime.sessionClosed = true;
+        }
+
+        const remainingActiveComponents: any = Object.values(ctxData?.components || []).filter(
+            (c: any) => c?.ctx?.active == true && !c?.ctx?.alwaysActive,
+        );
+        const activeAsyncComponents: any = Object.values(ctxData?.components || []).filter(
+            (c: any) => !c?.ctx?.output?._error && Array.isArray(c?.ctx?._job_components) && c?.ctx?._job_components.length > 0,
+        );
+
+        if (remainingActiveComponents.length == 0 && activeAsyncComponents.length == 0 /*&& awaitingInputs.length == 0*/) {
+            runtime.sessionClosed = true;
+        }
+
+        if (runtime.circularLimitReached) {
+            const circularLimitData = runtime.checkCircularLimit();
+            const error = `Circular Calls Limit Reached on ${circularLimitData}. Current agent circular limit is ${agent.circularLimit}`;
+            runtime.sessionClosed = true;
+            return { state, dbgSession, sessionClosed: runtime.sessionClosed, error };
+        }
+
+        const step = this.curStep >= 1 ? this.curStep - 1 : 0; //current state was executed in previous step
+
+        if (deltaOnly) {
+            const delta = {};
+            for (let cptId in state) {
+                const cpt = state[cptId];
+
+                //workaround, here we are supposed to test component steps that are equalt to current step
+                //but due to an inconsistency, the Async component has sometimes a step greater than the current step
+                if (cpt.step >= step) delta[cptId] = cpt;
+                //FIXME : identify the root cause of this issue and replace >= with ==
+            }
+            //return { state: delta, dbgSession, sessionClosed: runtime.sessionClosed, step };
+            state = delta;
+        }
+
+        return { state, dbgSession, sessionClosed: runtime.sessionClosed, step };
+    }
+
+    /**
+     * This method is called by the agent to run a process cycle, it will run all active components and return the results
+     * The function is called multiple times until all components are executed and no more active components are available
+     * @returns
+     */
+    public async runCycle() {
+        console.debug(
+            `runCycle agentId=${this.agent.id} wfReqId=${this.workflowReqId}  reqTag=${this.reqTag} session=${this.xDebugRun} cycleId=${this.processID}`,
+        );
+        //this.checkRuntimeContext();
+
+        const runtime = this;
+        const agent = this.agent;
+        const ctxData = runtime.agentContext;
+        const dbgAllComponents: any = runtime.xDebugPendingInject || Object.values(ctxData?.components || []);
+
+        //first try to find exclusive active components
+        let dbgActiveComponents: any;
+        dbgActiveComponents = dbgAllComponents.filter((c: any) => c?.ctx?.active == true && c?.ctx?.exclusive == true);
+        //if no exclusive active components, find all active components
+        if (!dbgActiveComponents || dbgActiveComponents.length == 0)
+            dbgActiveComponents = dbgAllComponents.filter(
+                (c: any) =>
+                    c?.ctx?.active == true ||
+                    (!c?.ctx?.output?._error && Array.isArray(c?.ctx?._job_components) && c?.ctx?._job_components.length > 0),
+            );
+        //find waiting components that was not previously run
+        const dbgActiveWaitingComponents: any = dbgAllComponents.filter(
+            (c: any) => c?.ctx?.active == true && c?.ctx?.status && typeof c?.ctx?.output !== undefined,
+        );
+        const dbgActiveReadyComponents: any = dbgAllComponents.filter(
+            (c: any) =>
+                (c?.ctx?.active == true && !c?.ctx?.status) ||
+                (!c?.ctx?.output?._error && Array.isArray(c?.ctx?._job_components) && c?.ctx?._job_components.length > 0),
+        );
+        //const dbgActiveReadyComponents: any = dbgActiveComponents.filter((c: any) => c?.ctx?.active == true && !c?.ctx?.status);
+
+        let step: any;
+
+        if (!dbgActiveComponents || dbgActiveComponents.length == 0) {
+            runtime.sessionClosed = true;
+            step = {
+                state: { sessionClosed: true },
+                dbgSession: null,
+                //expiredDbgSession: runtime.xDebugRun || runtime.xDebugStop,
+                expiredDbgSession: runtime.xDebugId,
+                sessionClosed: true,
+            };
+        }
+
+        if (!step && dbgActiveComponents.length == dbgActiveWaitingComponents.length && ctxData.sessionResult) {
+            runtime.sessionClosed = true;
+            step = {
+                state: { sessionClosed: true },
+                dbgSession: null,
+                //expiredDbgSession: runtime.xDebugRun,
+                expiredDbgSession: runtime.xDebugId,
+                sessionClosed: true,
+            };
+        }
+        if (!step && dbgActiveReadyComponents.length > 0) {
+            const promises: any = [];
+
+            for (let dbgComponent of dbgActiveReadyComponents) {
+                const injectInput = runtime.xDebugPendingInject ? dbgComponent.ctx.input : undefined;
+
+                promises.push(agent.callComponent(dbgComponent.ctx.sourceId, dbgComponent.id, injectInput));
+            }
+            const dbgResults = await Promise.all(promises);
+            const state = dbgResults.length == 1 ? dbgResults[0] : dbgResults;
+
+            runtime.xDebugPendingInject = null;
+
+            const remainingActiveComponents: any = Object.values(ctxData?.components || []).filter((c: any) => c?.ctx?.active == true);
+            const activeAsyncComponents: any = Object.values(ctxData?.components || []).filter(
+                (c: any) => !c?.ctx?.output?._error && Array.isArray(c?.ctx?._job_components) && c?.ctx?._job_components.length > 0,
+            );
+            const dbgActiveWaitingComponents: any = dbgAllComponents.filter((c: any) => c?.ctx?.status && typeof c?.ctx?.output !== undefined);
+
+            if (dbgActiveWaitingComponents.length == remainingActiveComponents.length) {
+                ctxData.sessionResult = true;
+            }
+
+            //capture results
+            let sessionResults = dbgResults.flat().filter(
+                (e) =>
+                    e.id &&
+                    e.result &&
+                    !e.result._missing_inputs &&
+                    //check if this is the last component in the chain
+                    !agent.connections.find((c) => c.sourceId == e.id),
+            );
+
+            let errorResults = dbgResults.flat().filter((e) => e.id && (e.error || e.result?._error));
+
+            //also filter out erroneous components that are children of a loop
+            //otherwise, errors inside a loop will be reported as session results and can lead to wrong results or generated noise in the final agent output
+            errorResults = errorResults.filter((e) => {
+                return !ctxData?.components?.[e.id]?.ctx?.runtimeData?._ChildLoopData;
+            });
+
+            if (ctxData.sessionResult && sessionResults.length == 0 && runtime.sessionClosed) {
+                //no result ? check if we have errors
+                sessionResults = errorResults;
+            }
+
+            ctxData.sessionResults = sessionResults;
+            step = {
+                state,
+                dbgSession: runtime.xDebugRun,
+                sessionResult: runtime.agentContext.sessionResult,
+                sessionResults: runtime.agentContext.sessionResults,
+                errorResults,
+                sessionClosed: remainingActiveComponents.length == 0 && activeAsyncComponents.length == 0 /*&& awaitingInputs.length == 0*/,
+            };
+        } else {
+            runtime.sessionClosed = true;
+            //return { sessionClosed: true };
+            step = {
+                state: { sessionClosed: true },
+                dbgSession: null,
+                //expiredDbgSession: runtime.xDebugRun || runtime.xDebugStop,
+                expiredDbgSession: runtime.xDebugId,
+                sessionClosed: true,
+            };
+        }
+
+        this.checkCircularLimit();
+        if (step.sessionResults) {
+            AgentRuntime.processResults[this.processID].sessionResults.push(step.sessionResults);
+        }
+        if (step.errorResults) {
+            AgentRuntime.processResults[this.processID].errorResults.push(step.errorResults);
+        }
+
+        if (step?.sessionClosed || this.circularLimitReached) {
+            const finalResult = this.processResults();
+            step.finalResult = finalResult;
+            runtime.sessionClosed = true;
+        }
+
+        this.incStep();
+        this.sync();
+        return step;
+    }
+
+    private processResults() {
+        //this.checkCircularLimit();
+        let result: any = { error: 'Error processing results' };
+        const sessionResults = AgentRuntime.processResults[this.processID].sessionResults;
+        const errorResults = AgentRuntime.processResults[this.processID].errorResults;
+        if (this.circularLimitReached) {
+            const circularLimitData = this.circularLimitReached;
+            result = { error: `Circular Calls Limit Reached on ${circularLimitData}. Current circular limit is ${this.agent.circularLimit}` };
+        } else {
+            let state = [sessionResults, errorResults].flat(Infinity);
+            if (!state || state.length == 0) state = errorResults.flat(Infinity);
+
+            //post process run cycle results
+            //deduplicating redundant entries
+
+            const data = state
+                .reduce(
+                    (acc, current) => {
+                        if (!acc.seen[current.id]) {
+                            acc.result.push(current);
+                            acc.seen[current.id] = true;
+                        }
+                        return acc;
+                    },
+                    { seen: {}, result: [] },
+                )
+                .result.filter((e) => !e.result?._exclude);
+
+            //data.forEach((d: any) => delete d?.result?._debug);
+
+            result = data;
+            /////////////
+        }
+
+        //cleanup
+        delete AgentRuntime.processResults[this.processID];
+
+        this.sync();
+        return result;
+    }
+
+    public checkCircularLimit() {
+        if (this.circularLimitReached) return this.agentContext.circularLimitReached;
+        for (let componentId in AgentRuntime.tagsData[this.reqTag]) {
+            if (AgentRuntime.tagsData[this.reqTag][componentId] > this.agent.circularLimit) {
+                this.sessionClosed = true;
+                this.agentContext.circularLimitReached = componentId;
+                return componentId;
+            }
+        }
+        return false;
+    }
+
+    public async injectDebugOutput(componentId: string) {
+        let component: {
+            ctx?: Record<string, any>;
+        } = {};
+
+        if (this.xDebugPendingInject) {
+            component = this.xDebugPendingInject?.find((c: any) => c.id == componentId);
+        } else if (this.xMockDataInject) {
+            component = this.xMockDataInject?.find((c: any) => c.id == componentId);
+        }
+
+        if (component?.ctx?.output) {
+            //if all outputs values are empty, we don't inject
+            let allEmpty = true;
+            for (let key in component.ctx.output) {
+                if (component.ctx.output[key] != '') {
+                    allEmpty = false;
+                    break;
+                }
+            }
+            if (allEmpty) return null;
+
+            return component.ctx.output;
+        }
+    }
+    public getRuntimeData(componentId) {
+        const componentData = this.getComponentData(componentId);
+        if (!componentData) return {};
+        const rData = componentData.runtimeData || {};
+
+        return rData;
+    }
+    public updateRuntimeData(componentId, data) {
+        const componentData = this.getComponentData(componentId);
+        if (!componentData) return;
+        componentData.runtimeData = { ...componentData.runtimeData, ...data };
+
+        this.sync();
+    }
+
+    public saveRuntimeComponentData(componentId, data) {
+        this.updateComponent(componentId, { runtimeData: data });
+    }
+
+    public incStep() {
+        this.agentContext.incStep();
+    }
+    public updateComponent(componentId: string, data: any) {
+        this.agentContext.updateComponent(componentId, data);
+    }
+
+    public resetComponent(componentId: string) {
+        this.agentContext.resetComponent(componentId);
+    }
+
+    public getComponentData(componentId: string) {
+        return this.agentContext.getComponentData(componentId);
+    }
+}

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

@@ -0,0 +1,101 @@
+import { Agent } from './Agent.class';
+
+export class AgentSSE {
+    private connections: Map<string, any> = new Map();
+
+    /**
+     * Creates a new AgentSSE instance
+     * @param agent - The agent instance this SSE belongs to
+     */
+    constructor(private agent: Agent) {}
+
+    /**
+     * Updates or adds a response object with the given monitor ID
+     * Maintains backward compatibility by also setting the res property
+     * @param res - The response object to add or update
+     * @param monitorId - The monitor ID associated with this connection
+     * @returns The connection ID that was created or updated
+     */
+    public add(res: any, monitorId: string) {
+        // Store the connection
+        this.connections.set(monitorId, res);
+    }
+
+    public [Symbol.iterator](): IterableIterator<[string, any]> {
+        return this.connections.entries();
+    }
+
+    /**
+     * Sends an event to all connected clients
+     * @param _type - The event type
+     * @param _data - The event data
+     */
+    public async send(_type: string, _data: any): Promise<void> {
+        if (!_type || !_data) return;
+
+        // Format the data once
+        const data = typeof _data === 'string' ? _data : JSON.stringify(_data);
+        const message = `event: ${_type}\ndata: ${data}\n\n`;
+
+        // Send to all connections
+        for (const [id, connection] of this.connections.entries()) {
+            try {
+                if (connection && !connection.finished) {
+                    connection.write(message);
+                } else {
+                    // Remove closed connections
+                    this.connections.delete(id);
+                }
+            } catch (error) {
+                // Handle errors (connection might be closed)
+                console.error(`Error sending SSE to connection ${id}:`, error);
+                this.connections.delete(id);
+            }
+        }
+    }
+
+    /**
+     * Removes a specific connection
+     * @param connectionId - The ID of the connection to remove
+     * @returns True if the connection was found and removed, false otherwise
+     */
+    public remove(connectionId: string): boolean {
+        const connection = this.connections.get(connectionId);
+        if (connection) {
+            try {
+                if (connection && !connection.finished) {
+                    connection.end();
+                }
+            } catch (error) {
+                console.error(`Error closing connection ${connectionId}:`, error);
+            }
+            return this.connections.delete(connectionId);
+        }
+        return false;
+    }
+
+    /**
+     * Closes all connections
+     */
+    public async close(): Promise<void> {
+        for (const [id, connection] of this.connections.entries()) {
+            try {
+                if (connection && !connection.finished) {
+                    connection.end();
+                    console.log('Delibertly shutting down sse connection with id: ', id);
+                }
+            } catch (error) {
+                console.error(`Error closing connection ${id}:`, error);
+            }
+        }
+        this.connections.clear();
+    }
+
+    /**
+     * Gets the number of active connections
+     * @returns The number of active connections
+     */
+    public getConnectionCount(): number {
+        return this.connections.size;
+    }
+}