agent-swarm-kit 1.0.81 → 1.0.83

package/build/index.cjs

@@ -167,8 +167,8 @@ var MethodContextService = diScoped.scoped(/** @class */ (function () {
     return class_1;
 }()));
 
-var _a;
-var init = (_a = diKit.createActivator("agent-swarm"), _a.init), inject = _a.inject, provide = _a.provide;
+var _a$2;
+var init = (_a$2 = diKit.createActivator("agent-swarm"), _a$2.init), inject = _a$2.inject, provide = _a$2.provide;
 
 var baseServices$1 = {
     busService: Symbol('busService'),
@@ -228,103 +228,6 @@ var ExecutionContextService = diScoped.scoped(/** @class */ (function () {
     return class_1;
 }()));
 
-/**
- * LoggerService class that implements the ILogger interface.
- * Provides methods to log and debug messages.
- */
-var LoggerService = /** @class */ (function () {
-    function LoggerService() {
-        var _this = this;
-        this.methodContextService = inject(TYPES.methodContextService);
-        this.executionContextService = inject(TYPES.executionContextService);
-        this._logger = {
-            /**
-             * Logs messages.
-             * @param {...any} args - The messages to log.
-             */
-            log: function () {
-            },
-            /**
-             * Logs debug messages.
-             * @param {...any} args - The debug messages to log.
-             */
-            debug: function () {
-            },
-            /**
-             * Logs info messages.
-             * @param {...any} args - The info messages to log.
-             */
-            info: function () {
-            },
-        };
-        /**
-         * Logs messages using the current logger.
-         * @param {...any} args - The messages to log.
-         */
-        this.log = function () {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var methodContext = MethodContextService.hasContext()
-                ? _this.methodContextService.context
-                : null;
-            var executionContext = ExecutionContextService.hasContext()
-                ? _this.executionContextService.context
-                : null;
-            (_a = _this._logger).log.apply(_a, __spreadArray(__spreadArray([], __read(args), false), [{
-                    methodContext: methodContext,
-                    executionContext: executionContext,
-                }], false));
-        };
-        /**
-         * Logs debug messages using the current logger.
-         * @param {...any} args - The debug messages to log.
-         */
-        this.debug = function () {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var methodContext = MethodContextService.hasContext()
-                ? _this.methodContextService.context
-                : null;
-            var executionContext = ExecutionContextService.hasContext()
-                ? _this.executionContextService.context
-                : null;
-            (_a = _this._logger).debug.apply(_a, __spreadArray(__spreadArray([], __read(args), false), [{ methodContext: methodContext, executionContext: executionContext }], false));
-        };
-        /**
-         * Logs info messages using the current logger.
-         * @param {...any} args - The info messages to log.
-         */
-        this.info = function () {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var methodContext = MethodContextService.hasContext()
-                ? _this.methodContextService.context
-                : null;
-            var executionContext = ExecutionContextService.hasContext()
-                ? _this.executionContextService.context
-                : null;
-            (_a = _this._logger).info.apply(_a, __spreadArray(__spreadArray([], __read(args), false), [{ methodContext: methodContext, executionContext: executionContext }], false));
-        };
-        /**
-         * Sets a new logger.
-         * @param {ILogger} logger - The new logger to set.
-         */
-        this.setLogger = function (logger) {
-            _this._logger = logger;
-        };
-    }
-    return LoggerService;
-}());
-
 /**
  * Validates that the given output string is not empty.
  *
@@ -429,6 +332,8 @@ var removeXmlTags = function (input) {
         .trim();
 };
 
+var _a$1;
+var HISTORY_INSTANCE_WAIT_FOR_INIT = Symbol("wait-for-init");
 var INSTANCE_METHOD_NAME_WAIT_FOR_INIT = "HistoryInstance.waitForInit";
 var INSTANCE_METHOD_NAME_CTOR = "HistoryInstance.CTOR";
 var INSTANCE_METHOD_NAME_ITERATE_CONDITION = "HistoryInstance.iterate condition";
@@ -455,71 +360,31 @@ var HistoryInstance = /** @class */ (function () {
         this.callbacks = callbacks;
         this._array = [];
         /**
-         * Wait for the history to initialize.
+         * Makes the singleshot for initialization
          * @param agentName - The agent name.
          */
-        this.waitForInit = functoolsKit.singleshot(function (agentName) { return __awaiter(_this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+        this[_a$1] = functoolsKit.singleshot(function (agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                            swarm.loggerService.debug(INSTANCE_METHOD_NAME_WAIT_FOR_INIT, {
+                            swarm$1.loggerService.debug(INSTANCE_METHOD_NAME_WAIT_FOR_INIT, {
                                 clientId: this.clientId,
                                 agentName: agentName,
                             });
                         if (!this.callbacks.getData) return [3 /*break*/, 2];
-                        _a = this;
+                        _b = this;
                         return [4 /*yield*/, this.callbacks.getData(this.clientId, agentName)];
                     case 1:
-                        _a._array = _b.sent();
-                        _b.label = 2;
+                        _b._array = _c.sent();
+                        _c.label = 2;
                     case 2: return [2 /*return*/];
                 }
             });
         }); });
-        /**
-         * Push a new message to the history for a given agent.
-         * @param value - The model message to push.
-         * @param agentName - The agent name.
-         * @returns A promise that resolves when the message is pushed.
-         */
-        this.push = function (value, agentName) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                    swarm.loggerService.debug(INSTANCE_METHOD_NAME_PUSH, {
-                        clientId: this.clientId,
-                        agentName: agentName,
-                    });
-                this.callbacks.onPush &&
-                    this.callbacks.onPush(value, this.clientId, agentName);
-                this._array.push(value);
-                this.callbacks.onChange &&
-                    this.callbacks.onChange(this._array, this.clientId, agentName);
-                return [2 /*return*/, Promise.resolve()];
-            });
-        }); };
-        /**
-         * Dispose of the history for a given agent.
-         * @param agentName - The agent name or null.
-         * @returns A promise that resolves when the history is disposed.
-         */
-        this.dispose = function (agentName) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                    swarm.loggerService.debug(INSTANCE_METHOD_NAME_DISPOSE, {
-                        clientId: this.clientId,
-                        agentName: agentName,
-                    });
-                if (agentName === null) {
-                    this.callbacks.onDispose && this.callbacks.onDispose(this.clientId);
-                    this._array = [];
-                }
-                return [2 /*return*/, Promise.resolve()];
-            });
-        }); };
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-            swarm.loggerService.debug(INSTANCE_METHOD_NAME_CTOR, {
+            swarm$1.loggerService.debug(INSTANCE_METHOD_NAME_CTOR, {
                 clientId: this.clientId,
             });
         if (callbacks.onInit) {
@@ -531,47 +396,47 @@ var HistoryInstance = /** @class */ (function () {
         if (callbacks.filterCondition) {
             this.iterate = function (agentName) {
                 return __asyncGenerator(this, arguments, function () {
-                    var _a, _b, item, e_1_1, _c, _d, item, e_2_1;
-                    var e_1, _e, e_2, _f;
-                    return __generator(this, function (_g) {
-                        switch (_g.label) {
+                    var _b, _c, item, e_1_1, _d, _e, item, e_2_1;
+                    var e_1, _f, e_2, _g;
+                    return __generator(this, function (_h) {
+                        switch (_h.label) {
                             case 0:
                                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                                    swarm.loggerService.debug(INSTANCE_METHOD_NAME_ITERATE_CONDITION, {
+                                    swarm$1.loggerService.debug(INSTANCE_METHOD_NAME_ITERATE_CONDITION, {
                                         clientId: this.clientId,
                                         agentName: agentName,
                                     });
                                 if (!this.callbacks.onRead) return [3 /*break*/, 12];
                                 this.callbacks.onReadBegin &&
                                     this.callbacks.onReadBegin(this.clientId, agentName);
-                                _g.label = 1;
+                                _h.label = 1;
                             case 1:
-                                _g.trys.push([1, 8, 9, 10]);
-                                _a = __values(this._array), _b = _a.next();
-                                _g.label = 2;
+                                _h.trys.push([1, 8, 9, 10]);
+                                _b = __values(this._array), _c = _b.next();
+                                _h.label = 2;
                             case 2:
-                                if (!!_b.done) return [3 /*break*/, 7];
-                                item = _b.value;
+                                if (!!_c.done) return [3 /*break*/, 7];
+                                item = _c.value;
                                 return [4 /*yield*/, __await(this.callbacks.filterCondition(item, this.clientId, agentName))];
                             case 3:
-                                if (!_g.sent()) return [3 /*break*/, 6];
+                                if (!_h.sent()) return [3 /*break*/, 6];
                                 this.callbacks.onRead(item, this.clientId, agentName);
                                 return [4 /*yield*/, __await(item)];
-                            case 4: return [4 /*yield*/, _g.sent()];
+                            case 4: return [4 /*yield*/, _h.sent()];
                             case 5:
-                                _g.sent();
-                                _g.label = 6;
+                                _h.sent();
+                                _h.label = 6;
                             case 6:
-                                _b = _a.next();
+                                _c = _b.next();
                                 return [3 /*break*/, 2];
                             case 7: return [3 /*break*/, 10];
                             case 8:
-                                e_1_1 = _g.sent();
+                                e_1_1 = _h.sent();
                                 e_1 = { error: e_1_1 };
                                 return [3 /*break*/, 10];
                             case 9:
                                 try {
-                                    if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                                    if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
                                 }
                                 finally { if (e_1) throw e_1.error; }
                                 return [7 /*endfinally*/];
@@ -579,37 +444,37 @@ var HistoryInstance = /** @class */ (function () {
                                 this.callbacks.onReadEnd &&
                                     this.callbacks.onReadEnd(this.clientId, agentName);
                                 return [4 /*yield*/, __await(void 0)];
-                            case 11: return [2 /*return*/, _g.sent()];
+                            case 11: return [2 /*return*/, _h.sent()];
                             case 12:
                                 this.callbacks.onReadBegin &&
                                     this.callbacks.onReadBegin(this.clientId, agentName);
-                                _g.label = 13;
+                                _h.label = 13;
                             case 13:
-                                _g.trys.push([13, 20, 21, 22]);
-                                _c = __values(this._array), _d = _c.next();
-                                _g.label = 14;
+                                _h.trys.push([13, 20, 21, 22]);
+                                _d = __values(this._array), _e = _d.next();
+                                _h.label = 14;
                             case 14:
-                                if (!!_d.done) return [3 /*break*/, 19];
-                                item = _d.value;
+                                if (!!_e.done) return [3 /*break*/, 19];
+                                item = _e.value;
                                 return [4 /*yield*/, __await(this.callbacks.filterCondition(item, this.clientId, agentName))];
                             case 15:
-                                if (!_g.sent()) return [3 /*break*/, 18];
+                                if (!_h.sent()) return [3 /*break*/, 18];
                                 return [4 /*yield*/, __await(item)];
-                            case 16: return [4 /*yield*/, _g.sent()];
+                            case 16: return [4 /*yield*/, _h.sent()];
                             case 17:
-                                _g.sent();
-                                _g.label = 18;
+                                _h.sent();
+                                _h.label = 18;
                             case 18:
-                                _d = _c.next();
+                                _e = _d.next();
                                 return [3 /*break*/, 14];
                             case 19: return [3 /*break*/, 22];
                             case 20:
-                                e_2_1 = _g.sent();
+                                e_2_1 = _h.sent();
                                 e_2 = { error: e_2_1 };
                                 return [3 /*break*/, 22];
                             case 21:
                                 try {
-                                    if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                                    if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
                                 }
                                 finally { if (e_2) throw e_2.error; }
                                 return [7 /*endfinally*/];
@@ -623,6 +488,20 @@ var HistoryInstance = /** @class */ (function () {
             };
         }
     }
+    /**
+     * Wait for the history to initialize.
+     * @param agentName - The agent name.
+     */
+    HistoryInstance.prototype.waitForInit = function (agentName) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this[HISTORY_INSTANCE_WAIT_FOR_INIT](agentName)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
     /**
      * Iterate over the history messages for a given agent.
      * @param agentName - The agent name.
@@ -630,44 +509,44 @@ var HistoryInstance = /** @class */ (function () {
      */
     HistoryInstance.prototype.iterate = function (agentName) {
         return __asyncGenerator(this, arguments, function iterate_1() {
-            var _a, _b, item, e_3_1, _c, _d, item, e_4_1;
-            var e_3, _e, e_4, _f;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
+            var _b, _c, item, e_3_1, _d, _e, item, e_4_1;
+            var e_3, _f, e_4, _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
-                            swarm.loggerService.debug(INSTANCE_METHOD_NAME_ITERATE, {
+                            swarm$1.loggerService.debug(INSTANCE_METHOD_NAME_ITERATE, {
                                 clientId: this.clientId,
                                 agentName: agentName,
                             });
                         if (!this.callbacks.onRead) return [3 /*break*/, 11];
                         this.callbacks.onReadBegin &&
                             this.callbacks.onReadBegin(this.clientId, agentName);
-                        _g.label = 1;
+                        _h.label = 1;
                     case 1:
-                        _g.trys.push([1, 7, 8, 9]);
-                        _a = __values(this._array), _b = _a.next();
-                        _g.label = 2;
+                        _h.trys.push([1, 7, 8, 9]);
+                        _b = __values(this._array), _c = _b.next();
+                        _h.label = 2;
                     case 2:
-                        if (!!_b.done) return [3 /*break*/, 6];
-                        item = _b.value;
+                        if (!!_c.done) return [3 /*break*/, 6];
+                        item = _c.value;
                         this.callbacks.onRead(item, this.clientId, agentName);
                         return [4 /*yield*/, __await(item)];
-                    case 3: return [4 /*yield*/, _g.sent()];
+                    case 3: return [4 /*yield*/, _h.sent()];
                     case 4:
-                        _g.sent();
-                        _g.label = 5;
+                        _h.sent();
+                        _h.label = 5;
                     case 5:
-                        _b = _a.next();
+                        _c = _b.next();
                         return [3 /*break*/, 2];
                     case 6: return [3 /*break*/, 9];
                     case 7:
-                        e_3_1 = _g.sent();
+                        e_3_1 = _h.sent();
                         e_3 = { error: e_3_1 };
                         return [3 /*break*/, 9];
                     case 8:
                         try {
-                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                            if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
                         }
                         finally { if (e_3) throw e_3.error; }
                         return [7 /*endfinally*/];
@@ -675,34 +554,34 @@ var HistoryInstance = /** @class */ (function () {
                         this.callbacks.onReadEnd &&
                             this.callbacks.onReadEnd(this.clientId, agentName);
                         return [4 /*yield*/, __await(void 0)];
-                    case 10: return [2 /*return*/, _g.sent()];
+                    case 10: return [2 /*return*/, _h.sent()];
                     case 11:
                         this.callbacks.onReadBegin &&
                             this.callbacks.onReadBegin(this.clientId, agentName);
-                        _g.label = 12;
+                        _h.label = 12;
                     case 12:
-                        _g.trys.push([12, 18, 19, 20]);
-                        _c = __values(this._array), _d = _c.next();
-                        _g.label = 13;
+                        _h.trys.push([12, 18, 19, 20]);
+                        _d = __values(this._array), _e = _d.next();
+                        _h.label = 13;
                     case 13:
-                        if (!!_d.done) return [3 /*break*/, 17];
-                        item = _d.value;
+                        if (!!_e.done) return [3 /*break*/, 17];
+                        item = _e.value;
                         return [4 /*yield*/, __await(item)];
-                    case 14: return [4 /*yield*/, _g.sent()];
+                    case 14: return [4 /*yield*/, _h.sent()];
                     case 15:
-                        _g.sent();
-                        _g.label = 16;
+                        _h.sent();
+                        _h.label = 16;
                     case 16:
-                        _d = _c.next();
+                        _e = _d.next();
                         return [3 /*break*/, 13];
                     case 17: return [3 /*break*/, 20];
                     case 18:
-                        e_4_1 = _g.sent();
+                        e_4_1 = _h.sent();
                         e_4 = { error: e_4_1 };
                         return [3 /*break*/, 20];
                     case 19:
                         try {
-                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                            if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
                         }
                         finally { if (e_4) throw e_4.error; }
                         return [7 /*endfinally*/];
@@ -714,8 +593,45 @@ var HistoryInstance = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Push a new message to the history for a given agent.
+     * @param value - The model message to push.
+     * @param agentName - The agent name.
+     * @returns A promise that resolves when the message is pushed.
+     */
+    HistoryInstance.prototype.push = function (value, agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(INSTANCE_METHOD_NAME_PUSH, {
+                clientId: this.clientId,
+                agentName: agentName,
+            });
+        this.callbacks.onPush &&
+            this.callbacks.onPush(value, this.clientId, agentName);
+        this._array.push(value);
+        this.callbacks.onChange &&
+            this.callbacks.onChange(this._array, this.clientId, agentName);
+        return Promise.resolve();
+    };
+    /**
+     * Dispose of the history for a given agent.
+     * @param agentName - The agent name or null.
+     * @returns A promise that resolves when the history is disposed.
+     */
+    HistoryInstance.prototype.dispose = function (agentName) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+            swarm$1.loggerService.debug(INSTANCE_METHOD_NAME_DISPOSE, {
+                clientId: this.clientId,
+                agentName: agentName,
+            });
+        if (agentName === null) {
+            this.callbacks.onDispose && this.callbacks.onDispose(this.clientId);
+            this._array = [];
+        }
+        return Promise.resolve();
+    };
     return HistoryInstance;
 }());
+_a$1 = HISTORY_INSTANCE_WAIT_FOR_INIT;
 /**
  * Class representing History Utilities
  */
@@ -724,8 +640,8 @@ var HistoryUtils = /** @class */ (function () {
         var _this = this;
         this.HistoryFactory = HistoryInstance;
         this.HistoryCallbacks = {};
-        this.getHistory = functoolsKit.memoize(function (_a) {
-            var _b = __read(_a, 1), clientId = _b[0];
+        this.getHistory = functoolsKit.memoize(function (_b) {
+            var _c = __read(_b, 1), clientId = _c[0];
             return clientId;
         }, function (clientId) {
             return new _this.HistoryFactory(clientId, _this.HistoryCallbacks);
@@ -736,7 +652,7 @@ var HistoryUtils = /** @class */ (function () {
          */
         this.useHistoryAdapter = function (Ctor) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm.loggerService.log(METHOD_NAME_USE_HISTORY_ADAPTER);
+                swarm$1.loggerService.log(METHOD_NAME_USE_HISTORY_ADAPTER);
             _this.HistoryFactory = Ctor;
         };
         /**
@@ -745,7 +661,7 @@ var HistoryUtils = /** @class */ (function () {
          */
         this.useHistoryCallbacks = function (Callbacks) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm.loggerService.log(METHOD_NAME_USE_HISTORY_CALLBACKS);
+                swarm$1.loggerService.log(METHOD_NAME_USE_HISTORY_CALLBACKS);
             Object.assign(_this.HistoryCallbacks, Callbacks);
         };
         /**
@@ -757,11 +673,11 @@ var HistoryUtils = /** @class */ (function () {
          */
         this.push = function (value, clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
             var isInitial, history;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_PUSH, {
+                            swarm$1.loggerService.log(METHOD_NAME_PUSH, {
                                 clientId: clientId,
                                 agentName: agentName,
                                 value: value,
@@ -769,12 +685,12 @@ var HistoryUtils = /** @class */ (function () {
                         isInitial = this.getHistory.has(clientId);
                         return [4 /*yield*/, this.getHistory(clientId)];
                     case 1:
-                        history = _a.sent();
+                        history = _b.sent();
                         return [4 /*yield*/, history.waitForInit(agentName, isInitial)];
                     case 2:
-                        _a.sent();
+                        _b.sent();
                         return [4 /*yield*/, history.push(value, agentName)];
-                    case 3: return [2 /*return*/, _a.sent()];
+                    case 3: return [2 /*return*/, _b.sent()];
                 }
             });
         }); };
@@ -785,25 +701,27 @@ var HistoryUtils = /** @class */ (function () {
          * @returns A promise that resolves when the history is disposed.
          */
         this.dispose = function (clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
-            var isInitial, history;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var history;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_DISPOSE, {
+                            swarm$1.loggerService.log(METHOD_NAME_DISPOSE, {
                                 clientId: clientId,
                                 agentName: agentName,
                             });
-                        isInitial = this.getHistory.has(clientId);
+                        if (!this.getHistory.has(clientId)) {
+                            return [2 /*return*/];
+                        }
                         return [4 /*yield*/, this.getHistory(clientId)];
                     case 1:
-                        history = _a.sent();
-                        return [4 /*yield*/, history.waitForInit(agentName, isInitial)];
+                        history = _b.sent();
+                        return [4 /*yield*/, history.waitForInit(agentName, false)];
                     case 2:
-                        _a.sent();
+                        _b.sent();
                         return [4 /*yield*/, history.dispose(agentName)];
                     case 3:
-                        _a.sent();
+                        _b.sent();
                         if (agentName === null) {
                             this.getHistory.clear(clientId);
                         }
@@ -820,54 +738,54 @@ var HistoryUtils = /** @class */ (function () {
      */
     HistoryUtils.prototype.iterate = function (clientId, agentName) {
         return __asyncGenerator(this, arguments, function iterate_2() {
-            var isInitial, history, _a, _b, _c, item, e_5_1;
-            var _d, e_5, _e, _f;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
+            var isInitial, history, _b, _c, _d, item, e_5_1;
+            var _e, e_5, _f, _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_ITERATE, {
+                            swarm$1.loggerService.log(METHOD_NAME_ITERATE, {
                                 clientId: clientId,
                                 agentName: agentName,
                             });
                         isInitial = this.getHistory.has(clientId);
                         return [4 /*yield*/, __await(this.getHistory(clientId))];
                     case 1:
-                        history = _g.sent();
+                        history = _h.sent();
                         return [4 /*yield*/, __await(history.waitForInit(agentName, isInitial))];
                     case 2:
-                        _g.sent();
-                        _g.label = 3;
+                        _h.sent();
+                        _h.label = 3;
                     case 3:
-                        _g.trys.push([3, 10, 11, 16]);
-                        _a = true, _b = __asyncValues(history.iterate(agentName));
-                        _g.label = 4;
-                    case 4: return [4 /*yield*/, __await(_b.next())];
+                        _h.trys.push([3, 10, 11, 16]);
+                        _b = true, _c = __asyncValues(history.iterate(agentName));
+                        _h.label = 4;
+                    case 4: return [4 /*yield*/, __await(_c.next())];
                     case 5:
-                        if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 9];
-                        _f = _c.value;
-                        _a = false;
-                        item = _f;
+                        if (!(_d = _h.sent(), _e = _d.done, !_e)) return [3 /*break*/, 9];
+                        _g = _d.value;
+                        _b = false;
+                        item = _g;
                         return [4 /*yield*/, __await(item)];
-                    case 6: return [4 /*yield*/, _g.sent()];
+                    case 6: return [4 /*yield*/, _h.sent()];
                     case 7:
-                        _g.sent();
-                        _g.label = 8;
+                        _h.sent();
+                        _h.label = 8;
                     case 8:
-                        _a = true;
+                        _b = true;
                         return [3 /*break*/, 4];
                     case 9: return [3 /*break*/, 16];
                     case 10:
-                        e_5_1 = _g.sent();
+                        e_5_1 = _h.sent();
                         e_5 = { error: e_5_1 };
                         return [3 /*break*/, 16];
                     case 11:
-                        _g.trys.push([11, , 14, 15]);
-                        if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 13];
-                        return [4 /*yield*/, __await(_e.call(_b))];
+                        _h.trys.push([11, , 14, 15]);
+                        if (!(!_b && !_e && (_f = _c.return))) return [3 /*break*/, 13];
+                        return [4 /*yield*/, __await(_f.call(_c))];
                     case 12:
-                        _g.sent();
-                        _g.label = 13;
+                        _h.sent();
+                        _h.label = 13;
                     case 13: return [3 /*break*/, 15];
                     case 14:
                         if (e_5) throw e_5.error;
@@ -908,6 +826,441 @@ var nameToTitle = function (name) {
     return __spreadArray(["".concat(word.charAt(0).toUpperCase()).concat(word.slice(1))], __read(rest), false).join(' ');
 };
 
+var _a;
+var LOGGER_INSTANCE_WAIT_FOR_INIT = Symbol("wait-for-init");
+/**
+ * @class LoggerInstance
+ * @implements ILoggerInstance
+ * @description Logger instance class.
+ */
+var LoggerInstance = /** @class */ (function () {
+    function LoggerInstance(clientId, callbacks) {
+        var _this = this;
+        this.clientId = clientId;
+        this.callbacks = callbacks;
+        this[_a] = functoolsKit.singleshot(function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                if (this.callbacks.onInit) {
+                    this.callbacks.onInit(this.clientId);
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    }
+    /**
+     * @method waitForInit
+     * @description Waits for initialization.
+     * @returns {Promise<void>}
+     */
+    LoggerInstance.prototype.waitForInit = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this[LOGGER_INSTANCE_WAIT_FOR_INIT]()];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * @method log
+     * @description Logs a message.
+     * @param {string} topic - The topic of the log.
+     * @param {...any[]} args - The log arguments.
+     */
+    LoggerInstance.prototype.log = function (topic) {
+        var _b;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE && console.log.apply(console, __spreadArray(["[clientId=".concat(this.clientId, "]"), topic], __read(args), false));
+        if (this.callbacks.onLog) {
+            (_b = this.callbacks).onLog.apply(_b, __spreadArray([this.clientId, topic], __read(args), false));
+        }
+    };
+    /**
+     * @method debug
+     * @description Logs a debug message.
+     * @param {string} topic - The topic of the debug log.
+     * @param {...any[]} args - The debug log arguments.
+     */
+    LoggerInstance.prototype.debug = function (topic) {
+        var _b;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE && console.debug.apply(console, __spreadArray(["[clientId=".concat(this.clientId, "]"), topic], __read(args), false));
+        if (this.callbacks.onDebug) {
+            (_b = this.callbacks).onDebug.apply(_b, __spreadArray([this.clientId, topic], __read(args), false));
+        }
+    };
+    /**
+     * @method info
+     * @description Logs an info message.
+     * @param {string} topic - The topic of the info log.
+     * @param {...any[]} args - The info log arguments.
+     */
+    LoggerInstance.prototype.info = function (topic) {
+        var _b;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_CONSOLE && console.info.apply(console, __spreadArray(["[clientId=".concat(this.clientId, "]"), topic], __read(args), false));
+        if (this.callbacks.onInfo) {
+            (_b = this.callbacks).onInfo.apply(_b, __spreadArray([this.clientId, topic], __read(args), false));
+        }
+    };
+    /**
+     * @method dispose
+     * @description Disposes the logger instance.
+     */
+    LoggerInstance.prototype.dispose = function () {
+        if (this.callbacks.onDispose) {
+            this.callbacks.onDispose(this.clientId);
+        }
+    };
+    return LoggerInstance;
+}());
+_a = LOGGER_INSTANCE_WAIT_FOR_INIT;
+/**
+ * @class LoggerUtils
+ * @implements ILoggerAdapter, ILoggerControl
+ * @description Utility class for logger.
+ */
+var LoggerUtils = /** @class */ (function () {
+    function LoggerUtils() {
+        var _this = this;
+        this.LoggerFactory = LoggerInstance;
+        this.LoggerCallbacks = {};
+        this.getLogger = functoolsKit.memoize(function (_b) {
+            var _c = __read(_b, 1), clientId = _c[0];
+            return clientId;
+        }, function (clientId) { return new _this.LoggerFactory(clientId, _this.LoggerCallbacks); });
+        /**
+         * @method useCommonAdapter
+         * @description Sets the common logger adapter.
+         * @param {ILogger} logger - The logger instance.
+         */
+        this.useCommonAdapter = function (logger) {
+            swarm$1.loggerService.setLogger(logger);
+        };
+        /**
+         * @method useClientCallbacks
+         * @description Sets the client-specific callbacks.
+         * @param {Partial<ILoggerInstanceCallbacks>} Callbacks - The callbacks.
+         */
+        this.useClientCallbacks = function (Callbacks) {
+            Object.assign(_this.LoggerCallbacks, Callbacks);
+        };
+        /**
+         * @method useClientAdapter
+         * @description Sets the client-specific logger adapter.
+         * @param {TLoggerInstanceCtor} Ctor - The logger instance constructor.
+         */
+        this.useClientAdapter = function (Ctor) {
+            _this.LoggerFactory = Ctor;
+        };
+        /**
+         * @method logClient
+         * @description Logs a message for a specific client.
+         * @param {string} clientId - The client ID.
+         * @param {string} topic - The topic of the log.
+         * @param {...any[]} args - The log arguments.
+         * @returns {Promise<void>}
+         */
+        this.logClient = function (clientId, topic) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG) {
+                                return [2 /*return*/];
+                            }
+                            if (!swarm$1.sessionValidationService.hasSession(clientId)) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, MethodContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                    var _b;
+                                    return __generator(this, function (_c) {
+                                        switch (_c.label) {
+                                            case 0: return [4 /*yield*/, (_b = swarm$1.loggerService).log.apply(_b, __spreadArray([topic], __read(args), false))];
+                                            case 1:
+                                                _c.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); }, {
+                                    clientId: clientId,
+                                    agentName: "",
+                                    methodName: "LoggerUtils.logClient",
+                                    stateName: "",
+                                    storageName: "",
+                                    swarmName: "",
+                                })];
+                        case 1:
+                            _b.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * @method infoClient
+         * @description Logs an info message for a specific client.
+         * @param {string} clientId - The client ID.
+         * @param {string} topic - The topic of the info log.
+         * @param {...any[]} args - The info log arguments.
+         * @returns {Promise<void>}
+         */
+        this.infoClient = function (clientId, topic) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO) {
+                                return [2 /*return*/];
+                            }
+                            if (!swarm$1.sessionValidationService.hasSession(clientId)) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, MethodContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                    var _b;
+                                    return __generator(this, function (_c) {
+                                        switch (_c.label) {
+                                            case 0: return [4 /*yield*/, (_b = swarm$1.loggerService).info.apply(_b, __spreadArray([topic], __read(args), false))];
+                                            case 1:
+                                                _c.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); }, {
+                                    clientId: clientId,
+                                    agentName: "",
+                                    methodName: "LoggerUtils.infoClient",
+                                    stateName: "",
+                                    storageName: "",
+                                    swarmName: "",
+                                })];
+                        case 1:
+                            _b.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * @method debugClient
+         * @description Logs a debug message for a specific client.
+         * @param {string} clientId - The client ID.
+         * @param {string} topic - The topic of the debug log.
+         * @param {...any[]} args - The debug log arguments.
+         * @returns {Promise<void>}
+         */
+        this.debugClient = function (clientId, topic) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG) {
+                                return [2 /*return*/];
+                            }
+                            if (!swarm$1.sessionValidationService.hasSession(clientId)) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, MethodContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                    var _b;
+                                    return __generator(this, function (_c) {
+                                        switch (_c.label) {
+                                            case 0: return [4 /*yield*/, (_b = swarm$1.loggerService).debug.apply(_b, __spreadArray([topic], __read(args), false))];
+                                            case 1:
+                                                _c.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); }, {
+                                    clientId: clientId,
+                                    agentName: "",
+                                    methodName: "LoggerUtils.debugClient",
+                                    stateName: "",
+                                    storageName: "",
+                                    swarmName: "",
+                                })];
+                        case 1:
+                            _b.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * @method log
+         * @description Logs a message.
+         * @param {string} clientId - The client ID.
+         * @param {string} topic - The topic of the log.
+         * @param {...any[]} args - The log arguments.
+         * @returns {Promise<void>}
+         */
+        this.log = function (clientId, topic) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function () {
+                var isInitial, logger;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG) {
+                                return [2 /*return*/];
+                            }
+                            if (!swarm$1.sessionValidationService.hasSession(clientId)) {
+                                return [2 /*return*/];
+                            }
+                            isInitial = this.getLogger.has(clientId);
+                            logger = this.getLogger(clientId);
+                            return [4 /*yield*/, logger.waitForInit(isInitial)];
+                        case 1:
+                            _b.sent();
+                            return [4 /*yield*/, logger.log.apply(logger, __spreadArray([topic], __read(args), false))];
+                        case 2:
+                            _b.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * @method debug
+         * @description Logs a debug message.
+         * @param {string} clientId - The client ID.
+         * @param {string} topic - The topic of the debug log.
+         * @param {...any[]} args - The debug log arguments.
+         * @returns {Promise<void>}
+         */
+        this.debug = function (clientId, topic) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function () {
+                var isInitial, logger;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG) {
+                                return [2 /*return*/];
+                            }
+                            if (!swarm$1.sessionValidationService.hasSession(clientId)) {
+                                return [2 /*return*/];
+                            }
+                            isInitial = this.getLogger.has(clientId);
+                            logger = this.getLogger(clientId);
+                            return [4 /*yield*/, logger.waitForInit(isInitial)];
+                        case 1:
+                            _b.sent();
+                            return [4 /*yield*/, logger.debug.apply(logger, __spreadArray([topic], __read(args), false))];
+                        case 2:
+                            _b.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * @method info
+         * @description Logs an info message.
+         * @param {string} clientId - The client ID.
+         * @param {string} topic - The topic of the info log.
+         * @param {...any[]} args - The info log arguments.
+         * @returns {Promise<void>}
+         */
+        this.info = function (clientId, topic) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function () {
+                var isInitial, logger;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO) {
+                                return [2 /*return*/];
+                            }
+                            if (!swarm$1.sessionValidationService.hasSession(clientId)) {
+                                return [2 /*return*/];
+                            }
+                            isInitial = this.getLogger.has(clientId);
+                            logger = this.getLogger(clientId);
+                            return [4 /*yield*/, logger.waitForInit(isInitial)];
+                        case 1:
+                            _b.sent();
+                            return [4 /*yield*/, logger.info.apply(logger, __spreadArray([topic], __read(args), false))];
+                        case 2:
+                            _b.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * @method dispose
+         * @description Disposes the logger instance.
+         * @param {string} clientId - The client ID.
+         * @returns {Promise<void>}
+         */
+        this.dispose = function (clientId) { return __awaiter(_this, void 0, void 0, function () {
+            var logger;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.getLogger.has(clientId)) {
+                            return [2 /*return*/];
+                        }
+                        logger = this.getLogger(clientId);
+                        return [4 /*yield*/, logger.waitForInit(false)];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, logger.dispose()];
+                    case 2:
+                        _b.sent();
+                        this.getLogger.clear(clientId);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+    }
+    return LoggerUtils;
+}());
+/**
+ * @constant LoggerAdapter
+ * @description Singleton instance of LoggerUtils.
+ */
+var LoggerAdapter = new LoggerUtils();
+/**
+ * @constant Logger
+ * @description Logger control interface.
+ */
+var Logger = LoggerAdapter;
+
 /**
  * @description `ask for agent function` in `llama3.1:8b` to troubleshoot (need CC_OLLAMA_EMIT_TOOL_PROTOCOL to be turned off)
  */
@@ -928,19 +1281,11 @@ var CC_EMPTY_OUTPUT_PLACEHOLDERS = [
     "Could you please repeat that? I didn’t catch it.",
 ];
 var CC_SWARM_AGENT_CHANGED = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-    switch (_a.label) {
-        case 0: return [4 /*yield*/, functoolsKit.sleep(100)];
-        case 1: return [2 /*return*/, _a.sent()];
-    }
+    return [2 /*return*/, Promise.resolve()];
 }); }); };
 var CC_SWARM_DEFAULT_AGENT = function (_a, _b, defaultAgent_1) { return __awaiter(void 0, [_a, _b, defaultAgent_1], void 0, function (_c, _d, defaultAgent) {
     return __generator(this, function (_e) {
-        switch (_e.label) {
-            case 0: return [4 /*yield*/, functoolsKit.sleep(100)];
-            case 1:
-                _e.sent();
-                return [2 /*return*/, defaultAgent];
-        }
+        return [2 /*return*/, defaultAgent];
     });
 }); };
 var CC_AGENT_DEFAULT_VALIDATION = validateDefault;
@@ -961,6 +1306,7 @@ var CC_AGENT_HISTORY_FILTER = function (agentName) {
 var CC_AGENT_OUTPUT_TRANSFORM = removeXmlTags;
 var CC_KEEP_MESSAGES = 5;
 var CC_GET_AGENT_HISTORY_ADAPTER = function () { return HistoryAdapter; };
+var CC_GET_CLIENT_LOGGER_ADAPTER = function () { return LoggerAdapter; };
 var CC_AGENT_OUTPUT_MAP = function (message) { return message; };
 var CC_AGENT_SYSTEM_PROMPT = undefined;
 var CC_STORAGE_SEARCH_SIMILARITY = 0.65;
@@ -968,12 +1314,14 @@ var CC_STORAGE_SEARCH_POOL = 5;
 var CC_LOGGER_ENABLE_INFO = false;
 var CC_LOGGER_ENABLE_DEBUG = false;
 var CC_LOGGER_ENABLE_LOG = true;
+var CC_LOGGER_ENABLE_CONSOLE = false;
 var CC_NAME_TO_TITLE = nameToTitle;
 var GLOBAL_CONFIG = {
     CC_TOOL_CALL_EXCEPTION_PROMPT: CC_TOOL_CALL_EXCEPTION_PROMPT,
     CC_EMPTY_OUTPUT_PLACEHOLDERS: CC_EMPTY_OUTPUT_PLACEHOLDERS,
     CC_KEEP_MESSAGES: CC_KEEP_MESSAGES,
     CC_GET_AGENT_HISTORY_ADAPTER: CC_GET_AGENT_HISTORY_ADAPTER,
+    CC_GET_CLIENT_LOGGER_ADAPTER: CC_GET_CLIENT_LOGGER_ADAPTER,
     CC_SWARM_AGENT_CHANGED: CC_SWARM_AGENT_CHANGED,
     CC_SWARM_DEFAULT_AGENT: CC_SWARM_DEFAULT_AGENT,
     CC_AGENT_DEFAULT_VALIDATION: CC_AGENT_DEFAULT_VALIDATION,
@@ -988,12 +1336,130 @@ var GLOBAL_CONFIG = {
     CC_LOGGER_ENABLE_INFO: CC_LOGGER_ENABLE_INFO,
     CC_LOGGER_ENABLE_DEBUG: CC_LOGGER_ENABLE_DEBUG,
     CC_LOGGER_ENABLE_LOG: CC_LOGGER_ENABLE_LOG,
+    CC_LOGGER_ENABLE_CONSOLE: CC_LOGGER_ENABLE_CONSOLE,
     CC_NAME_TO_TITLE: CC_NAME_TO_TITLE,
 };
 var setConfig = function (config) {
     Object.assign(GLOBAL_CONFIG, config);
 };
 
+var NOOP_LOGGER = {
+    /**
+     * Logs normal level messages.
+     */
+    log: function () {
+    },
+    /**
+     * Logs debug level messages.
+     */
+    debug: function () {
+    },
+    /**
+     * Logs info level messages.
+     */
+    info: function () {
+    },
+};
+/**
+ * LoggerService class that implements the ILogger interface.
+ * Provides methods to log and debug messages.
+ */
+var LoggerService = /** @class */ (function () {
+    function LoggerService() {
+        var _this = this;
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.executionContextService = inject(TYPES.executionContextService);
+        this._commonLogger = NOOP_LOGGER;
+        /**
+         * Creates the client logs adapter using factory
+         */
+        this.getLoggerAdapter = functoolsKit.singleshot(GLOBAL_CONFIG.CC_GET_CLIENT_LOGGER_ADAPTER);
+        /**
+         * Logs messages using the current logger.
+         * @param {...any} args - The messages to log.
+         */
+        this.log = function (topic) {
+            var _a, _b;
+            var _c;
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            var methodContext = MethodContextService.hasContext()
+                ? _this.methodContextService.context
+                : null;
+            var executionContext = ExecutionContextService.hasContext()
+                ? _this.executionContextService.context
+                : null;
+            var clientId = (_c = methodContext === null || methodContext === void 0 ? void 0 : methodContext.clientId) !== null && _c !== void 0 ? _c : executionContext === null || executionContext === void 0 ? void 0 : executionContext.clientId;
+            var context = {
+                methodContext: methodContext,
+                executionContext: executionContext,
+            };
+            clientId && (_a = _this.getLoggerAdapter()).log.apply(_a, __spreadArray(__spreadArray([clientId, topic], __read(args), false), [context], false));
+            (_b = _this._commonLogger).log.apply(_b, __spreadArray(__spreadArray([topic], __read(args), false), [context], false));
+        };
+        /**
+         * Logs debug messages using the current logger.
+         * @param {...any} args - The debug messages to log.
+         */
+        this.debug = function (topic) {
+            var _a, _b;
+            var _c;
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            var methodContext = MethodContextService.hasContext()
+                ? _this.methodContextService.context
+                : null;
+            var executionContext = ExecutionContextService.hasContext()
+                ? _this.executionContextService.context
+                : null;
+            var clientId = (_c = methodContext === null || methodContext === void 0 ? void 0 : methodContext.clientId) !== null && _c !== void 0 ? _c : executionContext === null || executionContext === void 0 ? void 0 : executionContext.clientId;
+            var context = {
+                methodContext: methodContext,
+                executionContext: executionContext,
+            };
+            clientId && (_a = _this.getLoggerAdapter()).debug.apply(_a, __spreadArray(__spreadArray([clientId, topic], __read(args), false), [context], false));
+            (_b = _this._commonLogger).debug.apply(_b, __spreadArray(__spreadArray([topic], __read(args), false), [context], false));
+        };
+        /**
+         * Logs info messages using the current logger.
+         * @param {...any} args - The info messages to log.
+         */
+        this.info = function (topic) {
+            var _a, _b;
+            var _c;
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            var methodContext = MethodContextService.hasContext()
+                ? _this.methodContextService.context
+                : null;
+            var executionContext = ExecutionContextService.hasContext()
+                ? _this.executionContextService.context
+                : null;
+            var clientId = (_c = methodContext === null || methodContext === void 0 ? void 0 : methodContext.clientId) !== null && _c !== void 0 ? _c : executionContext === null || executionContext === void 0 ? void 0 : executionContext.clientId;
+            var context = {
+                methodContext: methodContext,
+                executionContext: executionContext,
+            };
+            clientId && (_a = _this.getLoggerAdapter()).info.apply(_a, __spreadArray(__spreadArray([clientId, topic], __read(args), false), [context], false));
+            (_b = _this._commonLogger).info.apply(_b, __spreadArray(__spreadArray([topic], __read(args), false), [context], false));
+        };
+        /**
+         * Sets a new logger.
+         * @param {ILogger} logger - The new logger to set.
+         */
+        this.setLogger = function (logger) {
+            _this._commonLogger = logger;
+        };
+    }
+    return LoggerService;
+}());
+
 /**
  * Service for managing agent schemas.
  */
@@ -2377,7 +2843,7 @@ var ClientSwarm = /** @class */ (function () {
                             this.params.logger.debug("ClientSwarm swarmName=".concat(this.params.swarmName, " clientId=").concat(this.params.clientId, " getAgentName"));
                         if (!(this._activeAgent === AGENT_NEED_FETCH)) return [3 /*break*/, 2];
                         _a = this;
-                        return [4 /*yield*/, GLOBAL_CONFIG.CC_SWARM_DEFAULT_AGENT(this.params.clientId, this.params.swarmName, this.params.defaultAgent)];
+                        return [4 /*yield*/, this.params.getActiveAgent(this.params.clientId, this.params.swarmName, this.params.defaultAgent)];
                     case 1:
                         _a._activeAgent = _b.sent();
                         _b.label = 2;
@@ -2475,15 +2941,19 @@ var ClientSwarm = /** @class */ (function () {
          * @param {AgentName} agentName - The name of the agent to set as active.
          */
         this.setAgentName = function (agentName) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                             this.params.logger.debug("ClientSwarm swarmName=".concat(this.params.swarmName, " clientId=").concat(this.params.clientId, " setAgentName agentName=").concat(agentName));
                         this._activeAgent = agentName;
-                        return [4 /*yield*/, this.params.onAgentChanged(this.params.clientId, agentName, this.params.swarmName)];
+                        return [4 /*yield*/, this.params.setActiveAgent(this.params.clientId, agentName, this.params.swarmName)];
                     case 1:
-                        _a.sent();
+                        _b.sent();
+                        if ((_a = this.params.callbacks) === null || _a === void 0 ? void 0 : _a.onAgentChanged) {
+                            this.params.callbacks.onAgentChanged(this.params.clientId, agentName, this.params.swarmName);
+                        }
                         return [4 /*yield*/, this.params.bus.emit(this.params.clientId, {
                                 type: "set-agent-name",
                                 source: "swarm-bus",
@@ -2497,7 +2967,7 @@ var ClientSwarm = /** @class */ (function () {
                                 clientId: this.params.clientId,
                             })];
                     case 2:
-                        _a.sent();
+                        _b.sent();
                         return [2 /*return*/];
                 }
             });
@@ -2540,7 +3010,7 @@ var SwarmConnectionService = /** @class */ (function () {
             return "".concat(clientId, "-").concat(swarmName);
         }, function (clientId, swarmName) {
             var e_1, _a;
-            var _b = _this.swarmSchemaService.get(swarmName), agentList = _b.agentList, defaultAgent = _b.defaultAgent, callbacks = _b.callbacks;
+            var _b = _this.swarmSchemaService.get(swarmName), agentList = _b.agentList, defaultAgent = _b.defaultAgent, callbacks = _b.callbacks, _c = _b.getActiveAgent, getActiveAgent = _c === void 0 ? GLOBAL_CONFIG.CC_SWARM_DEFAULT_AGENT : _c, _d = _b.setActiveAgent, setActiveAgent = _d === void 0 ? GLOBAL_CONFIG.CC_SWARM_AGENT_CHANGED : _d;
             var agentMap = {};
             try {
                 for (var agentList_1 = __values(agentList), agentList_1_1 = agentList_1.next(); !agentList_1_1.done; agentList_1_1 = agentList_1.next()) {
@@ -2562,22 +3032,8 @@ var SwarmConnectionService = /** @class */ (function () {
                 swarmName: swarmName,
                 logger: _this.loggerService,
                 bus: _this.busService,
-                onAgentChanged: function (clientId, agentName, swarmName) {
-                    return __awaiter(this, void 0, void 0, function () {
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    if (callbacks && callbacks.onAgentChanged) {
-                                        callbacks.onAgentChanged(clientId, agentName, swarmName);
-                                    }
-                                    return [4 /*yield*/, GLOBAL_CONFIG.CC_SWARM_AGENT_CHANGED(clientId, agentName, swarmName)];
-                                case 1:
-                                    _a.sent();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    });
-                },
+                getActiveAgent: getActiveAgent,
+                setActiveAgent: setActiveAgent,
                 callbacks: callbacks,
             });
         });
@@ -6718,6 +7174,7 @@ var validationServices = {
 };
 var swarm = __assign(__assign(__assign(__assign(__assign(__assign({}, baseServices), contextServices), connectionServices), schemaServices), publicServices), validationServices);
 init();
+var swarm$1 = swarm;
 
 var METHOD_NAME$C = "function.addAgent";
 /**
@@ -6728,11 +7185,11 @@ var METHOD_NAME$C = "function.addAgent";
  */
 var addAgent = function (agentSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             agentSchema: agentSchema,
         });
-    swarm.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
-    swarm.agentSchemaService.register(agentSchema.agentName, agentSchema);
+    swarm$1.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
+    swarm$1.agentSchemaService.register(agentSchema.agentName, agentSchema);
     return agentSchema.agentName;
 };
 
@@ -6746,11 +7203,11 @@ var METHOD_NAME$B = "function.addCompletion";
  */
 var addCompletion = function (completionSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$B, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             completionSchema: completionSchema,
         });
-    swarm.completionValidationService.addCompletion(completionSchema.completionName);
-    swarm.completionSchemaService.register(completionSchema.completionName, completionSchema);
+    swarm$1.completionValidationService.addCompletion(completionSchema.completionName);
+    swarm$1.completionSchemaService.register(completionSchema.completionName, completionSchema);
     return completionSchema.completionName;
 };
 
@@ -6763,11 +7220,11 @@ var METHOD_NAME$A = "function.addSwarm";
  */
 var addSwarm = function (swarmSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$A, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             swarmSchema: swarmSchema,
         });
-    swarm.swarmValidationService.addSwarm(swarmSchema.swarmName, swarmSchema);
-    swarm.swarmSchemaService.register(swarmSchema.swarmName, swarmSchema);
+    swarm$1.swarmValidationService.addSwarm(swarmSchema.swarmName, swarmSchema);
+    swarm$1.swarmSchemaService.register(swarmSchema.swarmName, swarmSchema);
     return swarmSchema.swarmName;
 };
 
@@ -6781,11 +7238,11 @@ var METHOD_NAME$z = "function.addTool";
  */
 var addTool = function (toolSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$z, {
+        swarm$1.loggerService.log(METHOD_NAME$z, {
             toolSchema: toolSchema,
         });
-    swarm.toolValidationService.addTool(toolSchema.toolName, toolSchema);
-    swarm.toolSchemaService.register(toolSchema.toolName, toolSchema);
+    swarm$1.toolValidationService.addTool(toolSchema.toolName, toolSchema);
+    swarm$1.toolSchemaService.register(toolSchema.toolName, toolSchema);
     return toolSchema.toolName;
 };
 
@@ -6798,12 +7255,12 @@ var METHOD_NAME$y = "function.addState";
  */
 var addState = function (stateSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$y, {
+        swarm$1.loggerService.log(METHOD_NAME$y, {
             stateSchema: stateSchema,
         });
-    swarm.stateSchemaService.register(stateSchema.stateName, stateSchema);
+    swarm$1.stateSchemaService.register(stateSchema.stateName, stateSchema);
     if (stateSchema.shared) {
-        swarm.stateConnectionService
+        swarm$1.stateConnectionService
             .getSharedStateRef("shared", stateSchema.stateName)
             .waitForInit();
     }
@@ -6819,11 +7276,11 @@ var METHOD_NAME$x = "function.addEmbedding";
  */
 var addEmbedding = function (embeddingSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$x, {
+        swarm$1.loggerService.log(METHOD_NAME$x, {
             embeddingSchema: embeddingSchema,
         });
-    swarm.embeddingValidationService.addEmbedding(embeddingSchema.embeddingName, embeddingSchema);
-    swarm.embeddingSchemaService.register(embeddingSchema.embeddingName, embeddingSchema);
+    swarm$1.embeddingValidationService.addEmbedding(embeddingSchema.embeddingName, embeddingSchema);
+    swarm$1.embeddingSchemaService.register(embeddingSchema.embeddingName, embeddingSchema);
     return embeddingSchema.embeddingName;
 };
 
@@ -6836,13 +7293,13 @@ var METHOD_NAME$w = "function.addStorage";
  */
 var addStorage = function (storageSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$w, {
+        swarm$1.loggerService.log(METHOD_NAME$w, {
             storageSchema: storageSchema,
         });
-    swarm.storageValidationService.addStorage(storageSchema.storageName, storageSchema);
-    swarm.storageSchemaService.register(storageSchema.storageName, storageSchema);
+    swarm$1.storageValidationService.addStorage(storageSchema.storageName, storageSchema);
+    swarm$1.storageSchemaService.register(storageSchema.storageName, storageSchema);
     if (storageSchema.shared) {
-        swarm.storageConnectionService
+        swarm$1.storageConnectionService
             .getSharedStorage("shared", storageSchema.storageName)
             .waitForInit();
     }
@@ -6864,28 +7321,28 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$v, {
+                    swarm$1.loggerService.log(METHOD_NAME$v, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, METHOD_NAME$v);
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$v);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$v);
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName)];
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log('function "commitUserMessage" skipped due to the agent change', {
+                        swarm$1.loggerService.log('function "commitUserMessage" skipped due to the agent change', {
                             currentAgentName: currentAgentName,
                             agentName: agentName,
                             clientId: clientId,
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.commitUserMessage(content, METHOD_NAME$v, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$v, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -6907,13 +7364,13 @@ var getAgentName = function (clientId) { return __awaiter(void 0, void 0, void 0
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$u, {
+                    swarm$1.loggerService.log(METHOD_NAME$u, {
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$u);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$u);
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName)];
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
@@ -6931,25 +7388,25 @@ var METHOD_NAME$t = "function.makeConnection";
  */
 var makeConnection = function (connector, clientId, swarmName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$t, {
+        swarm$1.loggerService.log(METHOD_NAME$t, {
             clientId: clientId,
             swarmName: swarmName,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$t);
-    swarm.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
-    var send = swarm.sessionPublicService.connect(connector, METHOD_NAME$t, clientId, swarmName);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
+    swarm$1.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
+    var send = swarm$1.sessionPublicService.connect(connector, METHOD_NAME$t, clientId, swarmName);
     return functoolsKit.queued(function (outgoing) { return __awaiter(void 0, void 0, void 0, function () {
         var _a;
         var _b;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
-                    swarm.sessionValidationService.validate(clientId, METHOD_NAME$t);
+                    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
                     _a = send;
                     _b = {
                         data: outgoing
                     };
-                    return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName)];
+                    return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName)];
                 case 1: return [4 /*yield*/, _a.apply(void 0, [(_b.agentName = _c.sent(),
                             _b.clientId = clientId,
                             _b)])];
@@ -6980,7 +7437,7 @@ makeConnection.scheduled = function (connector, clientId, swarmName, _a) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    if (!swarm.sessionValidationService.hasSession(clientId)) {
+                    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
                         return [2 /*return*/];
                     }
                     return [4 /*yield*/, send(content)];
@@ -7000,7 +7457,7 @@ makeConnection.scheduled = function (connector, clientId, swarmName, _a) {
             return __generator(this, function (_f) {
                 switch (_f.label) {
                     case 0:
-                        if (!swarm.sessionValidationService.hasSession(clientId)) {
+                        if (!swarm$1.sessionValidationService.hasSession(clientId)) {
                             return [2 /*return*/];
                         }
                         _c = commitUserMessage;
@@ -7058,15 +7515,15 @@ var createChangeAgent = functoolsKit.ttl(function (clientId) {
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
-                    swarm.sessionValidationService.validate(clientId, METHOD_NAME$s);
-                    swarm.agentValidationService.validate(agentName, METHOD_NAME$s);
-                    swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                    return [4 /*yield*/, Promise.all(swarm.swarmValidationService
+                    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+                    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
+                    swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                    return [4 /*yield*/, Promise.all(swarm$1.swarmValidationService
                             .getAgentList(swarmName)
                             .map(function (agentName) { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0: return [4 /*yield*/, swarm.agentPublicService.commitAgentChange(methodName, clientId, agentName)];
+                                    case 0: return [4 /*yield*/, swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName)];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -7075,22 +7532,22 @@ var createChangeAgent = functoolsKit.ttl(function (clientId) {
                         }); }))];
                 case 1:
                     _d.sent();
-                    return [4 /*yield*/, swarm.agentPublicService.dispose(methodName, clientId, agentName)];
+                    return [4 /*yield*/, swarm$1.agentPublicService.dispose(methodName, clientId, agentName)];
                 case 2:
                     _d.sent();
-                    return [4 /*yield*/, swarm.historyPublicService.dispose(methodName, clientId, agentName)];
+                    return [4 /*yield*/, swarm$1.historyPublicService.dispose(methodName, clientId, agentName)];
                 case 3:
                     _d.sent();
-                    _b = (_a = swarm.swarmPublicService).setAgentRef;
+                    _b = (_a = swarm$1.swarmPublicService).setAgentRef;
                     _c = [methodName,
                         clientId,
                         swarmName,
                         agentName];
-                    return [4 /*yield*/, swarm.agentPublicService.createAgentRef(methodName, clientId, agentName)];
+                    return [4 /*yield*/, swarm$1.agentPublicService.createAgentRef(methodName, clientId, agentName)];
                 case 4: return [4 /*yield*/, _b.apply(_a, _c.concat([_d.sent()]))];
                 case 5:
                     _d.sent();
-                    return [4 /*yield*/, swarm.swarmPublicService.setAgentName(agentName, methodName, clientId, swarmName)];
+                    return [4 /*yield*/, swarm$1.swarmPublicService.setAgentName(agentName, methodName, clientId, swarmName)];
                 case 6:
                     _d.sent();
                     return [2 /*return*/];
@@ -7129,7 +7586,7 @@ var changeAgent = function (agentName, clientId) { return __awaiter(void 0, void
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$s, {
+                    swarm$1.loggerService.log(METHOD_NAME$s, {
                         agentName: agentName,
                         clientId: clientId,
                     });
@@ -7162,28 +7619,26 @@ var disposeConnection = function (clientId_1, swarmName_1) {
             switch (_a.label) {
                 case 0:
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log(METHOD_NAME$r, {
+                        swarm$1.loggerService.log(METHOD_NAME$r, {
                             clientId: clientId,
                             swarmName: swarmName,
                         });
-                    swarm.swarmValidationService.validate(swarmName, methodName);
-                    swarm.sessionValidationService.removeSession(clientId);
-                    swarm.busService.dispose(clientId);
-                    return [4 /*yield*/, swarm.sessionPublicService.dispose(methodName, clientId, swarmName)];
+                    swarm$1.swarmValidationService.validate(swarmName, methodName);
+                    return [4 /*yield*/, swarm$1.sessionPublicService.dispose(methodName, clientId, swarmName)];
                 case 1:
                     _a.sent();
-                    return [4 /*yield*/, swarm.swarmPublicService.dispose(methodName, clientId, swarmName)];
+                    return [4 /*yield*/, swarm$1.swarmPublicService.dispose(methodName, clientId, swarmName)];
                 case 2:
                     _a.sent();
-                    return [4 /*yield*/, Promise.all(swarm.swarmValidationService
+                    return [4 /*yield*/, Promise.all(swarm$1.swarmValidationService
                             .getAgentList(swarmName)
                             .map(function (agentName) { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0: return [4 /*yield*/, swarm.agentPublicService.dispose(methodName, clientId, agentName)];
+                                    case 0: return [4 /*yield*/, swarm$1.agentPublicService.dispose(methodName, clientId, agentName)];
                                     case 1:
                                         _a.sent();
-                                        return [4 /*yield*/, swarm.historyPublicService.dispose(methodName, clientId, agentName)];
+                                        return [4 /*yield*/, swarm$1.historyPublicService.dispose(methodName, clientId, agentName)];
                                     case 2:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -7192,16 +7647,16 @@ var disposeConnection = function (clientId_1, swarmName_1) {
                         }); }))];
                 case 3:
                     _a.sent();
-                    return [4 /*yield*/, Promise.all(swarm.swarmValidationService
+                    return [4 /*yield*/, Promise.all(swarm$1.swarmValidationService
                             .getAgentList(swarmName)
                             .flatMap(function (agentName) {
-                            return swarm.agentValidationService.getStorageList(agentName);
+                            return swarm$1.agentValidationService.getStorageList(agentName);
                         })
                             .filter(function (storageName) { return !!storageName; })
                             .map(function (storageName) { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0: return [4 /*yield*/, swarm.storagePublicService.dispose(methodName, clientId, storageName)];
+                                    case 0: return [4 /*yield*/, swarm$1.storagePublicService.dispose(methodName, clientId, storageName)];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -7210,16 +7665,16 @@ var disposeConnection = function (clientId_1, swarmName_1) {
                         }); }))];
                 case 4:
                     _a.sent();
-                    return [4 /*yield*/, Promise.all(swarm.swarmValidationService
+                    return [4 /*yield*/, Promise.all(swarm$1.swarmValidationService
                             .getAgentList(swarmName)
                             .flatMap(function (agentName) {
-                            return swarm.agentValidationService.getStateList(agentName);
+                            return swarm$1.agentValidationService.getStateList(agentName);
                         })
                             .filter(function (stateName) { return !!stateName; })
                             .map(function (stateName) { return __awaiter(void 0, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0: return [4 /*yield*/, swarm.statePublicService.dispose(methodName, clientId, stateName)];
+                                    case 0: return [4 /*yield*/, swarm$1.statePublicService.dispose(methodName, clientId, stateName)];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -7231,6 +7686,11 @@ var disposeConnection = function (clientId_1, swarmName_1) {
                     return [4 /*yield*/, HistoryAdapter.dispose(clientId, null)];
                 case 6:
                     _a.sent();
+                    return [4 /*yield*/, LoggerAdapter.dispose(clientId)];
+                case 7:
+                    _a.sent();
+                    swarm$1.sessionValidationService.removeSession(clientId);
+                    swarm$1.busService.dispose(clientId);
                     return [2 /*return*/];
             }
         });
@@ -7252,9 +7712,9 @@ var createComplete = functoolsKit.ttl(function (clientId, swarmName) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    swarm.swarmValidationService.validate(swarmName, METHOD_NAME);
-                    swarm.sessionValidationService.addSession(clientId, swarmName, "complete");
-                    return [4 /*yield*/, swarm.sessionPublicService.execute(content, "user", METHOD_NAME, clientId, swarmName)];
+                    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME);
+                    swarm$1.sessionValidationService.addSession(clientId, swarmName, "complete");
+                    return [4 /*yield*/, swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME, clientId, swarmName)];
                 case 1:
                     result = _a.sent();
                     return [4 /*yield*/, disposeConnection(clientId, swarmName, METHOD_NAME)];
@@ -7297,7 +7757,7 @@ var complete = function (content, clientId, swarmName) { return __awaiter(void 0
             case 0:
                 executionId = functoolsKit.randomString();
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$q, {
+                    swarm$1.loggerService.log(METHOD_NAME$q, {
                         content: content,
                         clientId: clientId,
                         executionId: executionId,
@@ -7336,13 +7796,13 @@ var METHOD_NAME$p = "function.session";
 var session = function (clientId, swarmName) {
     var executionId = functoolsKit.randomString();
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$p, {
+        swarm$1.loggerService.log(METHOD_NAME$p, {
             clientId: clientId,
             swarmName: swarmName,
             executionId: executionId,
         });
-    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$p);
-    swarm.sessionValidationService.addSession(clientId, swarmName, "session");
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
+    swarm$1.sessionValidationService.addSession(clientId, swarmName, "session");
     return {
         /**
          * Completes the session with the given content.
@@ -7352,11 +7812,11 @@ var session = function (clientId, swarmName) {
          */
         complete: functoolsKit.queued(function (content) { return __awaiter(void 0, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$p);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
                 return [2 /*return*/, ExecutionContextService.runInContext(function () { return __awaiter(void 0, void 0, void 0, function () {
                         return __generator(this, function (_a) {
                             switch (_a.label) {
-                                case 0: return [4 /*yield*/, swarm.sessionPublicService.execute(content, "user", METHOD_NAME$p, clientId, swarmName)];
+                                case 0: return [4 /*yield*/, swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$p, clientId, swarmName)];
                                 case 1: return [2 /*return*/, _a.sent()];
                             }
                         });
@@ -7492,16 +7952,16 @@ var getRawHistory = function (clientId_1) {
             switch (_a.label) {
                 case 0:
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log(METHOD_NAME$o, {
+                        swarm$1.loggerService.log(METHOD_NAME$o, {
                             clientId: clientId,
                         });
-                    swarm.sessionValidationService.validate(clientId, methodName);
-                    swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                    swarm.swarmValidationService.validate(swarmName, methodName);
-                    return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                    swarm$1.sessionValidationService.validate(clientId, methodName);
+                    swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                    swarm$1.swarmValidationService.validate(swarmName, methodName);
+                    return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
                 case 1:
                     agentName = _a.sent();
-                    return [4 /*yield*/, swarm.historyPublicService.toArrayForRaw(methodName, clientId, agentName)];
+                    return [4 /*yield*/, swarm$1.historyPublicService.toArrayForRaw(methodName, clientId, agentName)];
                 case 2:
                     history = _a.sent();
                     return [2 /*return*/, __spreadArray([], __read(history), false)];
@@ -7524,13 +7984,13 @@ var getAgentHistory = function (clientId, agentName) { return __awaiter(void 0,
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$n, {
+                    swarm$1.loggerService.log(METHOD_NAME$n, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, METHOD_NAME$n);
-                prompt = swarm.agentSchemaService.get(agentName).prompt;
-                return [4 /*yield*/, swarm.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$n, clientId, agentName)];
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$n);
+                prompt = swarm$1.agentSchemaService.get(agentName).prompt;
+                return [4 /*yield*/, swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$n, clientId, agentName)];
             case 1:
                 history = _a.sent();
                 return [2 /*return*/, __spreadArray([], __read(history), false)];
@@ -7548,12 +8008,12 @@ var getSessionMode = function (clientId) { return __awaiter(void 0, void 0, void
     var swarmName;
     return __generator(this, function (_a) {
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm.loggerService.log(METHOD_NAME$m, {
+            swarm$1.loggerService.log(METHOD_NAME$m, {
                 clientId: clientId,
             });
-        swarmName = swarm.sessionValidationService.getSwarm(clientId);
-        swarm.swarmValidationService.validate(swarmName, METHOD_NAME$m);
-        return [2 /*return*/, swarm.sessionValidationService.getSessionMode(clientId)];
+        swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+        swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
+        return [2 /*return*/, swarm$1.sessionValidationService.getSessionMode(clientId)];
     });
 }); };
 
@@ -7572,22 +8032,22 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$l, {
+                    swarm$1.loggerService.log(METHOD_NAME$l, {
                         toolId: toolId,
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, METHOD_NAME$l);
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$l);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$l);
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName)];
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$l);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$l);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$l);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log('function "commitToolOutput" skipped due to the agent change', {
+                        swarm$1.loggerService.log('function "commitToolOutput" skipped due to the agent change', {
                             toolId: toolId,
                             currentAgentName: currentAgentName,
                             agentName: agentName,
@@ -7595,7 +8055,7 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$l, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$l, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -7618,28 +8078,28 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$k, {
+                    swarm$1.loggerService.log(METHOD_NAME$k, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, METHOD_NAME$k);
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$k);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$k);
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$k, clientId, swarmName)];
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$k);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$k);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$k);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$k, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
+                        swarm$1.loggerService.log('function "commitSystemMessage" skipped due to the agent change', {
                             currentAgentName: currentAgentName,
                             agentName: agentName,
                             clientId: clientId,
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.commitSystemMessage(content, METHOD_NAME$k, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$k, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -7661,27 +8121,27 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$j, {
+                    swarm$1.loggerService.log(METHOD_NAME$j, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, METHOD_NAME$j);
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$j);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$j);
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$j, clientId, swarmName)];
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$j);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$j, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log('function "commitFlush" skipped due to the agent change', {
+                        swarm$1.loggerService.log('function "commitFlush" skipped due to the agent change', {
                             currentAgentName: currentAgentName,
                             agentName: agentName,
                             clientId: clientId,
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.commitFlush(METHOD_NAME$j, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$j, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -7706,22 +8166,22 @@ var execute = function (content, clientId, agentName) { return __awaiter(void 0,
             case 0:
                 executionId = functoolsKit.randomString();
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$i, {
+                    swarm$1.loggerService.log(METHOD_NAME$i, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                         executionId: executionId,
                     });
-                swarm.agentValidationService.validate(agentName, METHOD_NAME$i);
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$i);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$i);
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName)];
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$i);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log('function "execute" skipped due to the agent change', {
+                        swarm$1.loggerService.log('function "execute" skipped due to the agent change', {
                             currentAgentName: currentAgentName,
                             agentName: agentName,
                             clientId: clientId,
@@ -7731,7 +8191,7 @@ var execute = function (content, clientId, agentName) { return __awaiter(void 0,
                 return [2 /*return*/, ExecutionContextService.runInContext(function () { return __awaiter(void 0, void 0, void 0, function () {
                         return __generator(this, function (_a) {
                             switch (_a.label) {
-                                case 0: return [4 /*yield*/, swarm.sessionPublicService.execute(content, "tool", METHOD_NAME$i, clientId, swarmName)];
+                                case 0: return [4 /*yield*/, swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$i, clientId, swarmName)];
                                 case 1: return [2 /*return*/, _a.sent()];
                             }
                         });
@@ -7760,31 +8220,31 @@ var emit = function (content, clientId, agentName) { return __awaiter(void 0, vo
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$h, {
+                    swarm$1.loggerService.log(METHOD_NAME$h, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                if (swarm.sessionValidationService.getSessionMode(clientId) !== "makeConnection") {
+                if (swarm$1.sessionValidationService.getSessionMode(clientId) !== "makeConnection") {
                     throw new Error("agent-swarm-kit emit session is not makeConnection clientId=".concat(clientId));
                 }
-                swarm.agentValidationService.validate(agentName, METHOD_NAME$h);
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$h);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$h);
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$h, clientId, swarmName)];
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$h);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$h);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$h, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log('function "emit" skipped due to the agent change', {
+                        swarm$1.loggerService.log('function "emit" skipped due to the agent change', {
                             currentAgentName: currentAgentName,
                             agentName: agentName,
                             clientId: clientId,
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.emit(content, METHOD_NAME$h, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.emit(content, METHOD_NAME$h, clientId, swarmName)];
             case 2: return [2 /*return*/, _a.sent()];
         }
     });
@@ -7804,15 +8264,15 @@ var commitToolOutputForce = function (toolId, content, clientId) { return __awai
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$g, {
+                    swarm$1.loggerService.log(METHOD_NAME$g, {
                         toolId: toolId,
                         content: content,
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$g);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$g);
-                return [4 /*yield*/, swarm.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$g, clientId, swarmName)];
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$g);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$g);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$g, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -7834,14 +8294,14 @@ var commitSystemMessageForce = function (content, clientId) { return __awaiter(v
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$f, {
+                    swarm$1.loggerService.log(METHOD_NAME$f, {
                         content: content,
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$f);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$f);
-                return [4 /*yield*/, swarm.sessionPublicService.commitSystemMessage(content, METHOD_NAME$f, clientId, swarmName)];
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$f);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$f);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$f, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -7862,14 +8322,14 @@ var commitFlushForce = function (clientId) { return __awaiter(void 0, void 0, vo
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$e, {
+                    swarm$1.loggerService.log(METHOD_NAME$e, {
                         clientId: clientId,
                         METHOD_NAME: METHOD_NAME$e,
                     });
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$e);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$e);
-                return [4 /*yield*/, swarm.sessionPublicService.commitFlush(METHOD_NAME$e, clientId, swarmName)];
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$e);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$e);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$e, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -7891,14 +8351,14 @@ var commitUserMessageForce = function (content, clientId) { return __awaiter(voi
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$d, {
+                    swarm$1.loggerService.log(METHOD_NAME$d, {
                         content: content,
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$d);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$d);
-                return [4 /*yield*/, swarm.sessionPublicService.commitUserMessage(content, METHOD_NAME$d, clientId, swarmName)];
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$d);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$d);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$d, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -7923,17 +8383,17 @@ var emitForce = function (content, clientId) { return __awaiter(void 0, void 0,
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$c, {
+                    swarm$1.loggerService.log(METHOD_NAME$c, {
                         content: content,
                         clientId: clientId,
                     });
-                if (swarm.sessionValidationService.getSessionMode(clientId) !== "makeConnection") {
+                if (swarm$1.sessionValidationService.getSessionMode(clientId) !== "makeConnection") {
                     throw new Error("agent-swarm-kit emitForce session is not makeConnection clientId=".concat(clientId));
                 }
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$c);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$c);
-                return [4 /*yield*/, swarm.sessionPublicService.emit(content, METHOD_NAME$c, clientId, swarmName)];
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$c);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$c);
+                return [4 /*yield*/, swarm$1.sessionPublicService.emit(content, METHOD_NAME$c, clientId, swarmName)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
@@ -7955,18 +8415,18 @@ var executeForce = function (content, clientId) { return __awaiter(void 0, void
     return __generator(this, function (_a) {
         executionId = functoolsKit.randomString();
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm.loggerService.log(METHOD_NAME$b, {
+            swarm$1.loggerService.log(METHOD_NAME$b, {
                 content: content,
                 clientId: clientId,
                 executionId: executionId,
             });
-        swarm.sessionValidationService.validate(clientId, METHOD_NAME$b);
-        swarmName = swarm.sessionValidationService.getSwarm(clientId);
-        swarm.swarmValidationService.validate(swarmName, METHOD_NAME$b);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$b);
+        swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+        swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$b);
         return [2 /*return*/, ExecutionContextService.runInContext(function () { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     switch (_a.label) {
-                        case 0: return [4 /*yield*/, swarm.sessionPublicService.execute(content, "tool", METHOD_NAME$b, clientId, swarmName)];
+                        case 0: return [4 /*yield*/, swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$b, clientId, swarmName)];
                         case 1: return [2 /*return*/, _a.sent()];
                     }
                 });
@@ -7990,7 +8450,7 @@ var validateClientId$d = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenEvent session not found for clientId=".concat(clientId));
     }
 };
@@ -8003,14 +8463,14 @@ var validateClientId$d = function (clientId) {
  */
 var listenEvent = function (clientId, topicName, fn) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$a, {
+        swarm$1.loggerService.log(METHOD_NAME$a, {
             clientId: clientId,
         });
     if (DISALLOWED_EVENT_SOURCE_LIST$2.has(topicName)) {
         throw new Error("agent-swarm listenEvent topic is reserved topicName=".concat(topicName));
     }
     validateClientId$d(clientId);
-    return swarm.busService.subscribe(clientId, topicName, function (_a) {
+    return swarm$1.busService.subscribe(clientId, topicName, function (_a) {
         var payload = _a.payload;
         return fn(payload);
     });
@@ -8029,7 +8489,7 @@ var validateClientId$c = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenEventOnce session not found for clientId=".concat(clientId));
     }
 };
@@ -8042,14 +8502,14 @@ var validateClientId$c = function (clientId) {
  */
 var listenEventOnce = function (clientId, topicName, filterFn, fn) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$9, {
+        swarm$1.loggerService.log(METHOD_NAME$9, {
             clientId: clientId,
         });
     if (DISALLOWED_EVENT_SOURCE_LIST$1.has(topicName)) {
         throw new Error("agent-swarm listenEventOnce topic is reserved topicName=".concat(topicName));
     }
     validateClientId$c(clientId);
-    return swarm.busService.once(clientId, topicName, function (_a) {
+    return swarm$1.busService.once(clientId, topicName, function (_a) {
         var payload = _a.payload;
         return filterFn(payload);
     }, function (_a) {
@@ -8071,7 +8531,7 @@ var getLastUserMessage = function (clientId) { return __awaiter(void 0, void 0,
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$8, {
+                    swarm$1.loggerService.log(METHOD_NAME$8, {
                         clientId: clientId,
                     });
                 return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$8)];
@@ -8099,7 +8559,7 @@ var getUserHistory = function (clientId) { return __awaiter(void 0, void 0, void
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$7, {
+                    swarm$1.loggerService.log(METHOD_NAME$7, {
                         clientId: clientId,
                     });
                 return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$7)];
@@ -8126,7 +8586,7 @@ var getAssistantHistory = function (clientId) { return __awaiter(void 0, void 0,
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$6, {
+                    swarm$1.loggerService.log(METHOD_NAME$6, {
                         clientId: clientId,
                     });
                 return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$6)];
@@ -8153,7 +8613,7 @@ var getLastAssistantMessage = function (clientId) { return __awaiter(void 0, voi
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$5, {
+                    swarm$1.loggerService.log(METHOD_NAME$5, {
                         clientId: clientId,
                     });
                 return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$5)];
@@ -8181,7 +8641,7 @@ var getLastSystemMessage = function (clientId) { return __awaiter(void 0, void 0
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$4, {
+                    swarm$1.loggerService.log(METHOD_NAME$4, {
                         clientId: clientId,
                     });
                 return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$4)];
@@ -8209,7 +8669,7 @@ var DEFAULT_TIMEOUT = 15 * 60;
 var makeAutoDispose = function (clientId, swarmName, _a) {
     var _b = _a === void 0 ? {} : _a, _c = _b.timeoutSeconds, timeoutSeconds = _c === void 0 ? DEFAULT_TIMEOUT : _c, onDestroy = _b.onDestroy;
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$3, {
+        swarm$1.loggerService.log(METHOD_NAME$3, {
             clientId: clientId,
             swarmName: swarmName,
         });
@@ -8228,7 +8688,7 @@ var makeAutoDispose = function (clientId, swarmName, _a) {
             switch (_a.label) {
                 case 0:
                     unSource();
-                    if (!swarm.sessionValidationService.hasSession(clientId)) return [3 /*break*/, 2];
+                    if (!swarm$1.sessionValidationService.hasSession(clientId)) return [3 /*break*/, 2];
                     return [4 /*yield*/, disposeConnection(clientId, swarmName)];
                 case 1:
                     _a.sent();
@@ -8275,13 +8735,13 @@ var DISALLOWED_EVENT_SOURCE_LIST = new Set([
  */
 var event = function (clientId, topicName, payload) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log(METHOD_NAME$2, {
+        swarm$1.loggerService.log(METHOD_NAME$2, {
             clientId: clientId,
         });
     if (DISALLOWED_EVENT_SOURCE_LIST.has(topicName)) {
         throw new Error("agent-swarm event topic is reserved topicName=".concat(topicName));
     }
-    return swarm.busService.emit(clientId, {
+    return swarm$1.busService.emit(clientId, {
         source: topicName,
         payload: payload,
         clientId: clientId,
@@ -8302,27 +8762,27 @@ var cancelOutput = function (clientId, agentName) { return __awaiter(void 0, voi
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME$1, {
+                    swarm$1.loggerService.log(METHOD_NAME$1, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, METHOD_NAME$1);
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME$1);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$1);
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$1, clientId, swarmName)];
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$1);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$1);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$1);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$1, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log('function "cancelOutput" skipped due to the agent change', {
+                        swarm$1.loggerService.log('function "cancelOutput" skipped due to the agent change', {
                             currentAgentName: currentAgentName,
                             agentName: agentName,
                             clientId: clientId,
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.swarmPublicService.cancelOutput(METHOD_NAME$1, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$1, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -8344,13 +8804,13 @@ var cancelOutputForce = function (clientId) { return __awaiter(void 0, void 0, v
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log(METHOD_NAME, {
+                    swarm$1.loggerService.log(METHOD_NAME, {
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, METHOD_NAME);
-                swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, METHOD_NAME);
-                return [4 /*yield*/, swarm.swarmPublicService.cancelOutput(METHOD_NAME, clientId, swarmName)];
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME);
+                return [4 /*yield*/, swarm$1.swarmPublicService.cancelOutput(METHOD_NAME, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -8362,7 +8822,7 @@ var validateClientId$b = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenAgentEvent session not found for clientId=".concat(clientId));
     }
 };
@@ -8373,18 +8833,18 @@ var validateClientId$b = function (clientId) {
  * @param {function} fn - The callback function to handle the event.
  */
 var listenAgentEvent = function (clientId, fn) {
-    swarm.loggerService.log("middleware listenAgentEvent", {
+    swarm$1.loggerService.log("middleware listenAgentEvent", {
         clientId: clientId,
     });
     validateClientId$b(clientId);
-    return swarm.busService.subscribe(clientId, "agent-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "agent-bus", fn);
 };
 
 var validateClientId$a = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenHistoryEvent session not found for clientId=".concat(clientId));
     }
 };
@@ -8395,18 +8855,18 @@ var validateClientId$a = function (clientId) {
  * @param {(event: IBusEvent) => void} fn - The callback function to handle the event.
  */
 var listenHistoryEvent = function (clientId, fn) {
-    swarm.loggerService.log("middleware listenHistoryEvent", {
+    swarm$1.loggerService.log("middleware listenHistoryEvent", {
         clientId: clientId,
     });
     validateClientId$a(clientId);
-    return swarm.busService.subscribe(clientId, "history-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "history-bus", fn);
 };
 
 var validateClientId$9 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenSessionEvent session not found for clientId=".concat(clientId));
     }
 };
@@ -8417,18 +8877,18 @@ var validateClientId$9 = function (clientId) {
  * @param {function} fn - The callback function to handle the session events.
  */
 var listenSessionEvent = function (clientId, fn) {
-    swarm.loggerService.log("middleware listenSessionEvent", {
+    swarm$1.loggerService.log("middleware listenSessionEvent", {
         clientId: clientId,
     });
     validateClientId$9(clientId);
-    return swarm.busService.subscribe(clientId, "session-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "session-bus", fn);
 };
 
 var validateClientId$8 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenStateEvent session not found for clientId=".concat(clientId));
     }
 };
@@ -8439,18 +8899,18 @@ var validateClientId$8 = function (clientId) {
  * @param {function} fn - The callback function to handle the event.
  */
 var listenStateEvent = function (clientId, fn) {
-    swarm.loggerService.log("middleware listenStateEvent", {
+    swarm$1.loggerService.log("middleware listenStateEvent", {
         clientId: clientId,
     });
     validateClientId$8(clientId);
-    return swarm.busService.subscribe(clientId, "state-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "state-bus", fn);
 };
 
 var validateClientId$7 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenStorageEvent session not found for clientId=".concat(clientId));
     }
 };
@@ -8461,18 +8921,18 @@ var validateClientId$7 = function (clientId) {
  * @param {function} fn - The callback function to handle the storage event.
  */
 var listenStorageEvent = function (clientId, fn) {
-    swarm.loggerService.log("middleware listenStorageEvent", {
+    swarm$1.loggerService.log("middleware listenStorageEvent", {
         clientId: clientId,
     });
     validateClientId$7(clientId);
-    return swarm.busService.subscribe(clientId, "storage-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "storage-bus", fn);
 };
 
 var validateClientId$6 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenSwarmEvent session not found for clientId=".concat(clientId));
     }
 };
@@ -8483,18 +8943,18 @@ var validateClientId$6 = function (clientId) {
  * @param {(event: IBusEvent) => void} fn - The callback function to handle the event.
  */
 var listenSwarmEvent = function (clientId, fn) {
-    swarm.loggerService.log("middleware listenSwarmEvent", {
+    swarm$1.loggerService.log("middleware listenSwarmEvent", {
         clientId: clientId,
     });
     validateClientId$6(clientId);
-    return swarm.busService.subscribe(clientId, "swarm-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "swarm-bus", fn);
 };
 
 var validateClientId$5 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenAgentEventOnce session not found for clientId=".concat(clientId));
     }
 };
@@ -8505,18 +8965,18 @@ var validateClientId$5 = function (clientId) {
  * @param {function} fn - The callback function to handle the event.
  */
 var listenAgentEventOnce = function (clientId, filterFn, fn) {
-    swarm.loggerService.log("middleware listenAgentEventOnce", {
+    swarm$1.loggerService.log("middleware listenAgentEventOnce", {
         clientId: clientId,
     });
     validateClientId$5(clientId);
-    return swarm.busService.once(clientId, "agent-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "agent-bus", filterFn, fn);
 };
 
 var validateClientId$4 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenHistoryEventOnce session not found for clientId=".concat(clientId));
     }
 };
@@ -8527,18 +8987,18 @@ var validateClientId$4 = function (clientId) {
  * @param {(event: IBusEvent) => void} fn - The callback function to handle the event.
  */
 var listenHistoryEventOnce = function (clientId, filterFn, fn) {
-    swarm.loggerService.log("middleware listenHistoryEventOnce", {
+    swarm$1.loggerService.log("middleware listenHistoryEventOnce", {
         clientId: clientId,
     });
     validateClientId$4(clientId);
-    return swarm.busService.once(clientId, "history-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "history-bus", filterFn, fn);
 };
 
 var validateClientId$3 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenSessionEventOnce session not found for clientId=".concat(clientId));
     }
 };
@@ -8549,18 +9009,18 @@ var validateClientId$3 = function (clientId) {
  * @param {function} fn - The callback function to handle the session events.
  */
 var listenSessionEventOnce = function (clientId, filterFn, fn) {
-    swarm.loggerService.log("middleware listenSessionEventOnce", {
+    swarm$1.loggerService.log("middleware listenSessionEventOnce", {
         clientId: clientId,
     });
     validateClientId$3(clientId);
-    return swarm.busService.once(clientId, "session-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "session-bus", filterFn, fn);
 };
 
 var validateClientId$2 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenStateEventOnce session not found for clientId=".concat(clientId));
     }
 };
@@ -8571,18 +9031,18 @@ var validateClientId$2 = function (clientId) {
  * @param {function} fn - The callback function to handle the event.
  */
 var listenStateEventOnce = function (clientId, filterFn, fn) {
-    swarm.loggerService.log("middleware listenStateEventOnce", {
+    swarm$1.loggerService.log("middleware listenStateEventOnce", {
         clientId: clientId,
     });
     validateClientId$2(clientId);
-    return swarm.busService.once(clientId, "state-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "state-bus", filterFn, fn);
 };
 
 var validateClientId$1 = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenStorageEventOnce session not found for clientId=".concat(clientId));
     }
 };
@@ -8593,18 +9053,18 @@ var validateClientId$1 = function (clientId) {
  * @param {function} fn - The callback function to handle the storage event.
  */
 var listenStorageEventOnce = function (clientId, filterFn, fn) {
-    swarm.loggerService.log("middleware listenStorageEventOnce", {
+    swarm$1.loggerService.log("middleware listenStorageEventOnce", {
         clientId: clientId,
     });
     validateClientId$1(clientId);
-    return swarm.busService.once(clientId, "storage-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "storage-bus", filterFn, fn);
 };
 
 var validateClientId = function (clientId) {
     if (clientId === "*") {
         return;
     }
-    if (!swarm.sessionValidationService.hasSession(clientId)) {
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
         throw new Error("agent-swarm listenSwarmEventOnce session not found for clientId=".concat(clientId));
     }
 };
@@ -8615,11 +9075,11 @@ var validateClientId = function (clientId) {
  * @param {(event: IBusEvent) => void} fn - The callback function to handle the event.
  */
 var listenSwarmEventOnce = function (clientId, filterFn, fn) {
-    swarm.loggerService.log("middleware listenSwarmEventOnce", {
+    swarm$1.loggerService.log("middleware listenSwarmEventOnce", {
         clientId: clientId,
     });
     validateClientId(clientId);
-    return swarm.busService.once(clientId, "swarm-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "swarm-bus", filterFn, fn);
 };
 
 var METHOD_NAME_TAKE = "StorageUtils.take";
@@ -8646,18 +9106,18 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_TAKE, {
+                            swarm$1.loggerService.log(METHOD_NAME_TAKE, {
                                 search: payload.search,
                                 total: payload.total,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                                 score: payload.score,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_TAKE);
-                        if (!swarm.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_TAKE);
+                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (take)"));
                         }
-                        return [4 /*yield*/, swarm.storagePublicService.take(payload.search, payload.total, METHOD_NAME_TAKE, payload.clientId, payload.storageName, payload.score)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.take(payload.search, payload.total, METHOD_NAME_TAKE, payload.clientId, payload.storageName, payload.score)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
@@ -8676,16 +9136,16 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_UPSERT, {
+                            swarm$1.loggerService.log(METHOD_NAME_UPSERT, {
                                 item: payload.item,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_UPSERT);
-                        if (!swarm.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_UPSERT);
+                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (upsert)"));
                         }
-                        return [4 /*yield*/, swarm.storagePublicService.upsert(payload.item, METHOD_NAME_UPSERT, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.upsert(payload.item, METHOD_NAME_UPSERT, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8703,16 +9163,16 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_REMOVE, {
+                            swarm$1.loggerService.log(METHOD_NAME_REMOVE, {
                                 itemId: payload.itemId,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_REMOVE);
-                        if (!swarm.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_REMOVE);
+                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (remove)"));
                         }
-                        return [4 /*yield*/, swarm.storagePublicService.remove(payload.itemId, METHOD_NAME_REMOVE, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.remove(payload.itemId, METHOD_NAME_REMOVE, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8731,16 +9191,16 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_GET$1, {
+                            swarm$1.loggerService.log(METHOD_NAME_GET$1, {
                                 itemId: payload.itemId,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_GET$1);
-                        if (!swarm.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_GET$1);
+                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (get)"));
                         }
-                        return [4 /*yield*/, swarm.storagePublicService.get(payload.itemId, METHOD_NAME_GET$1, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.get(payload.itemId, METHOD_NAME_GET$1, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
@@ -8759,15 +9219,15 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_LIST, {
+                            swarm$1.loggerService.log(METHOD_NAME_LIST, {
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_LIST);
-                        if (!swarm.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_LIST);
+                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (list)"));
                         }
-                        return [4 /*yield*/, swarm.storagePublicService.list(METHOD_NAME_LIST, payload.clientId, payload.storageName, payload.filter)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.list(METHOD_NAME_LIST, payload.clientId, payload.storageName, payload.filter)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
@@ -8784,15 +9244,15 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_CLEAR, {
+                            swarm$1.loggerService.log(METHOD_NAME_CLEAR, {
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_CLEAR);
-                        if (!swarm.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_CLEAR);
+                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (clear)"));
                         }
-                        return [4 /*yield*/, swarm.storagePublicService.clear(METHOD_NAME_CLEAR, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.clear(METHOD_NAME_CLEAR, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8826,14 +9286,14 @@ var StateUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_GET, {
+                            swarm$1.loggerService.log(METHOD_NAME_GET, {
                                 clientId: payload.clientId,
                                 stateName: payload.stateName,
                             });
-                        if (!swarm.agentValidationService.hasState(payload.agentName, payload.stateName)) {
+                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
                             throw new Error("agent-swarm StateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (getState)"));
                         }
-                        return [4 /*yield*/, swarm.statePublicService.getState(METHOD_NAME_GET, payload.clientId, payload.stateName)];
+                        return [4 /*yield*/, swarm$1.statePublicService.getState(METHOD_NAME_GET, payload.clientId, payload.stateName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8855,17 +9315,17 @@ var StateUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log(METHOD_NAME_SET, {
+                            swarm$1.loggerService.log(METHOD_NAME_SET, {
                                 clientId: payload.clientId,
                                 stateName: payload.stateName,
                             });
-                        if (!swarm.agentValidationService.hasState(payload.agentName, payload.stateName)) {
+                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
                             throw new Error("agent-swarm StateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (setState)"));
                         }
                         if (!(typeof dispatchFn === "function")) return [3 /*break*/, 2];
-                        return [4 /*yield*/, swarm.statePublicService.setState(dispatchFn, METHOD_NAME_SET, payload.clientId, payload.stateName)];
+                        return [4 /*yield*/, swarm$1.statePublicService.setState(dispatchFn, METHOD_NAME_SET, payload.clientId, payload.stateName)];
                     case 1: return [2 /*return*/, _a.sent()];
-                    case 2: return [4 /*yield*/, swarm.statePublicService.setState(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                    case 2: return [4 /*yield*/, swarm$1.statePublicService.setState(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                             return [2 /*return*/, dispatchFn];
                         }); }); }, METHOD_NAME_SET, payload.clientId, payload.stateName)];
                     case 3: return [2 /*return*/, _a.sent()];
@@ -8881,27 +9341,6 @@ var StateUtils = /** @class */ (function () {
  */
 var State = new StateUtils();
 
-var METHOD_NAME_USE_LOGGER = "HistoryInstance.useLogger";
-var LoggerUtils = /** @class */ (function () {
-    function LoggerUtils() {
-        /**
-         * Sets the provided logger to the logger service.
-         * @param {ILogger} logger - The logger instance to be used.
-         */
-        this.useLogger = function (logger) {
-            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm.loggerService.log(METHOD_NAME_USE_LOGGER);
-            swarm.loggerService.setLogger(logger);
-        };
-    }
-    return LoggerUtils;
-}());
-/**
- * Instance of LoggerUtils to be used for logging.
- * @type {LoggerUtils}
- */
-var Logger = new LoggerUtils();
-
 /**
  * Function that recursively flattens a nested object to array of entries.
  */
@@ -8951,7 +9390,7 @@ var SchemaUtils = /** @class */ (function () {
          */
         this.serialize = function (data) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm.loggerService.log(METHOD_NAME_SERIALIZE, {
+                swarm$1.loggerService.log(METHOD_NAME_SERIALIZE, {
                     data: data,
                 });
             if (Array.isArray(data)) {
@@ -8994,6 +9433,8 @@ exports.History = History;
 exports.HistoryAdapter = HistoryAdapter;
 exports.HistoryInstance = HistoryInstance;
 exports.Logger = Logger;
+exports.LoggerAdapter = LoggerAdapter;
+exports.LoggerInstance = LoggerInstance;
 exports.MethodContextService = MethodContextService;
 exports.Schema = Schema;
 exports.State = State;