agent-swarm-kit 1.0.79 → 1.0.80

package/build/index.cjs

@@ -429,6 +429,17 @@ var removeXmlTags = function (input) {
         .trim();
 };
 
+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";
+var INSTANCE_METHOD_NAME_ITERATE = "HistoryInstance.iterate";
+var INSTANCE_METHOD_NAME_PUSH = "HistoryInstance.push";
+var INSTANCE_METHOD_NAME_DISPOSE = "HistoryInstance.dispose";
+var METHOD_NAME_USE_HISTORY_ADAPTER = "HistoryUtils.useHistoryAdapter";
+var METHOD_NAME_USE_HISTORY_CALLBACKS = "HistoryUtils.useHistoryCallbacks";
+var METHOD_NAME_ITERATE = "HistoryUtils.iterate";
+var METHOD_NAME_PUSH = "HistoryUtils.push";
+var METHOD_NAME_DISPOSE = "HistoryUtils.dispose";
 /**
  * Class representing a History Instance
  */
@@ -453,7 +464,7 @@ var HistoryInstance = /** @class */ (function () {
                 switch (_b.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("HistoryInstance waitForInit", {
+                            swarm.loggerService.log(INSTANCE_METHOD_NAME_WAIT_FOR_INIT, {
                                 clientId: this.clientId,
                                 agentName: agentName,
                             });
@@ -476,7 +487,7 @@ var HistoryInstance = /** @class */ (function () {
         this.push = function (value, agentName) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("HistoryInstance push", {
+                    swarm.loggerService.log(INSTANCE_METHOD_NAME_PUSH, {
                         clientId: this.clientId,
                         agentName: agentName,
                     });
@@ -496,7 +507,7 @@ var HistoryInstance = /** @class */ (function () {
         this.dispose = function (agentName) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("HistoryInstance dispose", {
+                    swarm.loggerService.log(INSTANCE_METHOD_NAME_DISPOSE, {
                         clientId: this.clientId,
                         agentName: agentName,
                     });
@@ -508,7 +519,7 @@ var HistoryInstance = /** @class */ (function () {
             });
         }); };
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm.loggerService.log("HistoryInstance CTOR", {
+            swarm.loggerService.log(INSTANCE_METHOD_NAME_CTOR, {
                 clientId: this.clientId,
             });
         if (callbacks.onInit) {
@@ -526,7 +537,7 @@ var HistoryInstance = /** @class */ (function () {
                         switch (_g.label) {
                             case 0:
                                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                                    swarm.loggerService.log("HistoryInstance iterate condition", {
+                                    swarm.loggerService.log(INSTANCE_METHOD_NAME_ITERATE_CONDITION, {
                                         clientId: this.clientId,
                                         agentName: agentName,
                                     });
@@ -625,7 +636,7 @@ var HistoryInstance = /** @class */ (function () {
                 switch (_g.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("HistoryInstance iterate", {
+                            swarm.loggerService.log(INSTANCE_METHOD_NAME_ITERATE, {
                                 clientId: this.clientId,
                                 agentName: agentName,
                             });
@@ -725,7 +736,7 @@ var HistoryUtils = /** @class */ (function () {
          */
         this.useHistoryAdapter = function (Ctor) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm.loggerService.log("HistoryUtils useHistoryAdapter");
+                swarm.loggerService.log(METHOD_NAME_USE_HISTORY_ADAPTER);
             _this.HistoryFactory = Ctor;
         };
         /**
@@ -734,7 +745,7 @@ var HistoryUtils = /** @class */ (function () {
          */
         this.useHistoryCallbacks = function (Callbacks) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm.loggerService.log("HistoryUtils useHistoryCallbacks");
+                swarm.loggerService.log(METHOD_NAME_USE_HISTORY_CALLBACKS);
             Object.assign(_this.HistoryCallbacks, Callbacks);
         };
         /**
@@ -750,7 +761,7 @@ var HistoryUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("HistoryUtils push", {
+                            swarm.loggerService.log(METHOD_NAME_PUSH, {
                                 clientId: clientId,
                                 agentName: agentName,
                                 value: value,
@@ -779,7 +790,7 @@ var HistoryUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("HistoryUtils dispose", {
+                            swarm.loggerService.log(METHOD_NAME_DISPOSE, {
                                 clientId: clientId,
                                 agentName: agentName,
                             });
@@ -815,7 +826,7 @@ var HistoryUtils = /** @class */ (function () {
                 switch (_g.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("HistoryUtils iterate", {
+                            swarm.loggerService.log(METHOD_NAME_ITERATE, {
                                 clientId: clientId,
                                 agentName: agentName,
                             });
@@ -6708,6 +6719,7 @@ var validationServices = {
 var swarm = __assign(__assign(__assign(__assign(__assign(__assign({}, baseServices), contextServices), connectionServices), schemaServices), publicServices), validationServices);
 init();
 
+var METHOD_NAME$C = "function.addAgent";
 /**
  * Adds a new agent to the agent registry. The swarm takes only those agents which was registered
  *
@@ -6716,7 +6728,7 @@ init();
  */
 var addAgent = function (agentSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function addAgent", {
+        swarm.loggerService.log(METHOD_NAME$C, {
             agentSchema: agentSchema,
         });
     swarm.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
@@ -6724,6 +6736,7 @@ var addAgent = function (agentSchema) {
     return agentSchema.agentName;
 };
 
+var METHOD_NAME$B = "function.addCompletion";
 /**
  * Adds a completion engine for agents. Agents could use different models and
  * framewords for completion like: mock, gpt4all, ollama, openai
@@ -6733,7 +6746,7 @@ var addAgent = function (agentSchema) {
  */
 var addCompletion = function (completionSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function addCompletion", {
+        swarm.loggerService.log(METHOD_NAME$B, {
             completionSchema: completionSchema,
         });
     swarm.completionValidationService.addCompletion(completionSchema.completionName);
@@ -6741,6 +6754,7 @@ var addCompletion = function (completionSchema) {
     return completionSchema.completionName;
 };
 
+var METHOD_NAME$A = "function.addSwarm";
 /**
  * Adds a new swarm to the system. The swarm is a root for starting client session
  *
@@ -6749,7 +6763,7 @@ var addCompletion = function (completionSchema) {
  */
 var addSwarm = function (swarmSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function addSwarm", {
+        swarm.loggerService.log(METHOD_NAME$A, {
             swarmSchema: swarmSchema,
         });
     swarm.swarmValidationService.addSwarm(swarmSchema.swarmName, swarmSchema);
@@ -6757,6 +6771,7 @@ var addSwarm = function (swarmSchema) {
     return swarmSchema.swarmName;
 };
 
+var METHOD_NAME$z = "function.addTool";
 /**
  * Adds a new tool for agents in a swarm. Tool should be registered in `addAgent`
  * declaration
@@ -6766,7 +6781,7 @@ var addSwarm = function (swarmSchema) {
  */
 var addTool = function (toolSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function addTool", {
+        swarm.loggerService.log(METHOD_NAME$z, {
             toolSchema: toolSchema,
         });
     swarm.toolValidationService.addTool(toolSchema.toolName, toolSchema);
@@ -6774,6 +6789,7 @@ var addTool = function (toolSchema) {
     return toolSchema.toolName;
 };
 
+var METHOD_NAME$y = "function.addState";
 /**
  * Adds a new state to the state registry. The swarm takes only those states which was registered
  *
@@ -6782,7 +6798,7 @@ var addTool = function (toolSchema) {
  */
 var addState = function (stateSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function addState", {
+        swarm.loggerService.log(METHOD_NAME$y, {
             stateSchema: stateSchema,
         });
     swarm.stateSchemaService.register(stateSchema.stateName, stateSchema);
@@ -6794,6 +6810,7 @@ var addState = function (stateSchema) {
     return stateSchema.stateName;
 };
 
+var METHOD_NAME$x = "function.addEmbedding";
 /**
  * Adds a new embedding to the embedding registry. The swarm takes only those embeddings which was registered
  *
@@ -6802,7 +6819,7 @@ var addState = function (stateSchema) {
  */
 var addEmbedding = function (embeddingSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function addEmbedding", {
+        swarm.loggerService.log(METHOD_NAME$x, {
             embeddingSchema: embeddingSchema,
         });
     swarm.embeddingValidationService.addEmbedding(embeddingSchema.embeddingName, embeddingSchema);
@@ -6810,6 +6827,7 @@ var addEmbedding = function (embeddingSchema) {
     return embeddingSchema.embeddingName;
 };
 
+var METHOD_NAME$w = "function.addStorage";
 /**
  * Adds a new storage to the storage registry. The swarm takes only those storages which was registered
  *
@@ -6818,7 +6836,7 @@ var addEmbedding = function (embeddingSchema) {
  */
 var addStorage = function (storageSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function addStorage", {
+        swarm.loggerService.log(METHOD_NAME$w, {
             storageSchema: storageSchema,
         });
     swarm.storageValidationService.addStorage(storageSchema.storageName, storageSchema);
@@ -6831,6 +6849,7 @@ var addStorage = function (storageSchema) {
     return storageSchema.storageName;
 };
 
+var METHOD_NAME$v = "function.commitSystemMessage";
 /**
  * Commits a user message to the active agent history in as swarm without answer.
  *
@@ -6840,22 +6859,21 @@ var addStorage = function (storageSchema) {
  * @returns {Promise<void>} - A promise that resolves when the message is committed.
  */
 var commitUserMessage = function (content, clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName, currentAgentName;
+    var swarmName, currentAgentName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function commitSystemMessage";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function commitSystemMessage", {
+                    swarm.loggerService.log(METHOD_NAME$v, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, "commitUserMessage");
-                swarm.sessionValidationService.validate(clientId, "commitUserMessage");
+                swarm.agentValidationService.validate(agentName, METHOD_NAME$v);
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$v);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "commitUserMessage");
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -6867,7 +6885,7 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.commitUserMessage(content, methodName, clientId, swarmName)];
+                return [4 /*yield*/, swarm.sessionPublicService.commitUserMessage(content, METHOD_NAME$v, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -6875,6 +6893,7 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
     });
 }); };
 
+var METHOD_NAME$u = "function.getAgentName";
 /**
  * Retrieves the agent name for a given client ID.
  *
@@ -6883,25 +6902,25 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
  * @throws Will throw an error if the client ID is invalid or if the swarm validation fails.
  */
 var getAgentName = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName;
+    var swarmName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function getAgentName";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function getAgentName", {
+                    swarm.loggerService.log(METHOD_NAME$u, {
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, "getAgentName");
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$u);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "getAgentName");
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
 
 var SCHEDULED_DELAY$1 = 1000;
+var METHOD_NAME$t = "function.makeConnection";
 /**
  * A connection factory for a client to a swarm and returns a function to send messages.
  *
@@ -6911,27 +6930,26 @@ var SCHEDULED_DELAY$1 = 1000;
  * @returns {SendMessageFn} - A function to send messages to the swarm.
  */
 var makeConnection = function (connector, clientId, swarmName) {
-    var methodName = "function makeConnection";
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function makeConnection", {
+        swarm.loggerService.log(METHOD_NAME$t, {
             clientId: clientId,
             swarmName: swarmName,
         });
-    swarm.swarmValidationService.validate(swarmName, "makeConnection");
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$t);
     swarm.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
-    var send = swarm.sessionPublicService.connect(connector, methodName, clientId, swarmName);
+    var send = swarm.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, "makeConnection");
+                    swarm.sessionValidationService.validate(clientId, METHOD_NAME$t);
                     _a = send;
                     _b = {
                         data: outgoing
                     };
-                    return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                    return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName)];
                 case 1: return [4 /*yield*/, _a.apply(void 0, [(_b.agentName = _c.sent(),
                             _b.clientId = clientId,
                             _b)])];
@@ -7017,6 +7035,7 @@ makeConnection.scheduled = function (connector, clientId, swarmName, _a) {
     }); };
 };
 
+var METHOD_NAME$s = "function.changeAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
  * @constant {number}
@@ -7039,8 +7058,8 @@ var createChangeAgent = functoolsKit.ttl(function (clientId) {
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
-                    swarm.sessionValidationService.validate(clientId, "changeAgent");
-                    swarm.agentValidationService.validate(agentName, "changeAgent");
+                    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
                             .getAgentList(swarmName)
@@ -7105,13 +7124,12 @@ var createGc$1 = functoolsKit.singleshot(function () { return __awaiter(void 0,
  * @returns {Promise<void>} - A promise that resolves when the agent is changed.
  */
 var changeAgent = function (agentName, clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, run;
+    var run;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function changeAgent";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function changeAgent", {
+                    swarm.loggerService.log(METHOD_NAME$s, {
                         agentName: agentName,
                         clientId: clientId,
                     });
@@ -7119,12 +7137,13 @@ var changeAgent = function (agentName, clientId) { return __awaiter(void 0, void
             case 1:
                 run = _a.sent();
                 createGc$1();
-                return [4 /*yield*/, run(methodName, agentName)];
+                return [4 /*yield*/, run(METHOD_NAME$s, agentName)];
             case 2: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
 
+var METHOD_NAME$r = "function.disposeConnection";
 /**
  * Disposes the session for a given client with all related swarms and agents.
  *
@@ -7138,16 +7157,16 @@ var disposeConnection = function (clientId_1, swarmName_1) {
         args_1[_i - 2] = arguments[_i];
     }
     return __awaiter(void 0, __spreadArray([clientId_1, swarmName_1], __read(args_1), false), void 0, function (clientId, swarmName, methodName) {
-        if (methodName === void 0) { methodName = "function disposeConnection"; }
+        if (methodName === void 0) { methodName = METHOD_NAME$r; }
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log("function disposeConnection", {
+                        swarm.loggerService.log(METHOD_NAME$r, {
                             clientId: clientId,
                             swarmName: swarmName,
                         });
-                    swarm.swarmValidationService.validate(swarmName, "disposeConnection");
+                    swarm.swarmValidationService.validate(swarmName, methodName);
                     swarm.sessionValidationService.removeSession(clientId);
                     swarm.busService.dispose(clientId);
                     return [4 /*yield*/, swarm.sessionPublicService.dispose(methodName, clientId, swarmName)];
@@ -7218,6 +7237,7 @@ var disposeConnection = function (clientId_1, swarmName_1) {
     });
 };
 
+var METHOD_NAME$q = "function.complete";
 var COMPLETE_TTL = 15 * 60 * 1000;
 var COMPLETE_GC = 60 * 1000;
 /**
@@ -7227,17 +7247,17 @@ var COMPLETE_GC = 60 * 1000;
  * @returns {TCompleteRun} The complete run function.
  */
 var createComplete = functoolsKit.ttl(function (clientId, swarmName) {
-    return functoolsKit.queued(function (methodName, content) { return __awaiter(void 0, void 0, void 0, function () {
+    return functoolsKit.queued(function (METHOD_NAME, content) { return __awaiter(void 0, void 0, void 0, function () {
         var result;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    swarm.swarmValidationService.validate(swarmName, "complete");
+                    swarm.swarmValidationService.validate(swarmName, METHOD_NAME);
                     swarm.sessionValidationService.addSession(clientId, swarmName, "complete");
-                    return [4 /*yield*/, swarm.sessionPublicService.execute(content, "user", methodName, clientId, swarmName)];
+                    return [4 /*yield*/, swarm.sessionPublicService.execute(content, "user", METHOD_NAME, clientId, swarmName)];
                 case 1:
                     result = _a.sent();
-                    return [4 /*yield*/, disposeConnection(clientId, swarmName, methodName)];
+                    return [4 /*yield*/, disposeConnection(clientId, swarmName, METHOD_NAME)];
                 case 2:
                     _a.sent();
                     return [2 /*return*/, result];
@@ -7271,14 +7291,13 @@ var createGc = functoolsKit.singleshot(function () { return __awaiter(void 0, vo
  * @returns {Promise<string>} The result of the complete function.
  */
 var complete = function (content, clientId, swarmName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, executionId, run;
+    var executionId, run;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function complete";
                 executionId = functoolsKit.randomString();
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function complete", {
+                    swarm.loggerService.log(METHOD_NAME$q, {
                         content: content,
                         clientId: clientId,
                         executionId: executionId,
@@ -7291,7 +7310,7 @@ var complete = function (content, clientId, swarmName) { 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*/, run(methodName, content)];
+                                case 0: return [4 /*yield*/, run(METHOD_NAME$q, content)];
                                 case 1: return [2 /*return*/, _a.sent()];
                             }
                         });
@@ -7304,6 +7323,7 @@ var complete = function (content, clientId, swarmName) { return __awaiter(void 0
 }); };
 
 var SCHEDULED_DELAY = 1000;
+var METHOD_NAME$p = "function.session";
 /**
  * Creates a session for the given client and swarm.
  *
@@ -7314,15 +7334,14 @@ var SCHEDULED_DELAY = 1000;
  * @returns {Function} dispose - A function to dispose of the session.
  */
 var session = function (clientId, swarmName) {
-    var methodName = "function session";
     var executionId = functoolsKit.randomString();
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function session", {
+        swarm.loggerService.log(METHOD_NAME$p, {
             clientId: clientId,
             swarmName: swarmName,
             executionId: executionId,
         });
-    swarm.swarmValidationService.validate(swarmName, "session");
+    swarm.swarmValidationService.validate(swarmName, METHOD_NAME$p);
     swarm.sessionValidationService.addSession(clientId, swarmName, "session");
     return {
         /**
@@ -7333,11 +7352,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, "session");
+                swarm.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", methodName, clientId, swarmName)];
+                                case 0: return [4 /*yield*/, swarm.sessionPublicService.execute(content, "user", METHOD_NAME$p, clientId, swarmName)];
                                 case 1: return [2 /*return*/, _a.sent()];
                             }
                         });
@@ -7355,7 +7374,7 @@ var session = function (clientId, swarmName) {
         dispose: function () { return __awaiter(void 0, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, disposeConnection(clientId, swarmName, methodName)];
+                    case 0: return [4 /*yield*/, disposeConnection(clientId, swarmName, METHOD_NAME$p)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -7454,6 +7473,7 @@ session.scheduled = function (clientId, swarmName, _a) {
     };
 };
 
+var METHOD_NAME$o = "function.getRawHistory";
 /**
  * Retrieves the raw history as it is for a given client ID without any modifications.
  *
@@ -7467,17 +7487,17 @@ var getRawHistory = function (clientId_1) {
     }
     return __awaiter(void 0, __spreadArray([clientId_1], __read(args_1), false), void 0, function (clientId, methodName) {
         var swarmName, agentName, history;
-        if (methodName === void 0) { methodName = "function getRawHistory"; }
+        if (methodName === void 0) { methodName = METHOD_NAME$o; }
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                        swarm.loggerService.log("function getRawHistory", {
+                        swarm.loggerService.log(METHOD_NAME$o, {
                             clientId: clientId,
                         });
-                    swarm.sessionValidationService.validate(clientId, "getRawHistory");
+                    swarm.sessionValidationService.validate(clientId, methodName);
                     swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                    swarm.swarmValidationService.validate(swarmName, "getRawHistory");
+                    swarm.swarmValidationService.validate(swarmName, methodName);
                     return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
                 case 1:
                     agentName = _a.sent();
@@ -7490,6 +7510,7 @@ var getRawHistory = function (clientId_1) {
     });
 };
 
+var METHOD_NAME$n = "function.getAgentHistory";
 /**
  * Retrieves the history prepared for a specific agent with resque algorithm tweaks
  *
@@ -7498,19 +7519,18 @@ var getRawHistory = function (clientId_1) {
  * @returns {Promise<Array>} - A promise that resolves to an array containing the agent's history.
  */
 var getAgentHistory = function (clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, prompt, history;
+    var prompt, history;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function getAgentHistory";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function getAgentHistory", {
+                    swarm.loggerService.log(METHOD_NAME$n, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, "getAgentHistory");
+                swarm.agentValidationService.validate(agentName, METHOD_NAME$n);
                 prompt = swarm.agentSchemaService.get(agentName).prompt;
-                return [4 /*yield*/, swarm.historyPublicService.toArrayForAgent(prompt, methodName, clientId, agentName)];
+                return [4 /*yield*/, swarm.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$n, clientId, agentName)];
             case 1:
                 history = _a.sent();
                 return [2 /*return*/, __spreadArray([], __read(history), false)];
@@ -7518,6 +7538,7 @@ var getAgentHistory = function (clientId, agentName) { return __awaiter(void 0,
     });
 }); };
 
+var METHOD_NAME$m = "function.getSessionMode";
 /**
  * Return the session mode (`"session" | "makeConnection" | "complete"`) for clientId
  *
@@ -7527,15 +7548,16 @@ 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("function getSessionMode", {
+            swarm.loggerService.log(METHOD_NAME$m, {
                 clientId: clientId,
             });
         swarmName = swarm.sessionValidationService.getSwarm(clientId);
-        swarm.swarmValidationService.validate(swarmName, "getSessionMode");
+        swarm.swarmValidationService.validate(swarmName, METHOD_NAME$m);
         return [2 /*return*/, swarm.sessionValidationService.getSessionMode(clientId)];
     });
 }); };
 
+var METHOD_NAME$l = "function.commitToolOutput";
 /**
  * Commits the tool output to the active agent in a swarm session
  *
@@ -7545,24 +7567,22 @@ var getSessionMode = function (clientId) { return __awaiter(void 0, void 0, void
  * @returns {Promise<void>} - A promise that resolves when the operation is complete.
  */
 var commitToolOutput = function (toolId, content, clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName, currentAgentName;
+    var swarmName, currentAgentName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function commitToolOutput";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function commitToolOutput", {
+                    swarm.loggerService.log(METHOD_NAME$l, {
                         toolId: toolId,
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
-                        methodName: methodName,
                     });
-                swarm.agentValidationService.validate(agentName, "commitSystemMessage");
-                swarm.sessionValidationService.validate(clientId, "commitToolOutput");
+                swarm.agentValidationService.validate(agentName, METHOD_NAME$l);
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$l);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "commitToolOutput");
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$l);
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$l, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -7575,7 +7595,7 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.commitToolOutput(toolId, content, methodName, clientId, swarmName)];
+                return [4 /*yield*/, swarm.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$l, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -7583,6 +7603,7 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
     });
 }); };
 
+var METHOD_NAME$k = "function.commitSystemMessage";
 /**
  * Commits a system message to the active agent in the swarm.
  *
@@ -7592,22 +7613,21 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
  * @returns {Promise<void>} - A promise that resolves when the message is committed.
  */
 var commitSystemMessage = function (content, clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName, currentAgentName;
+    var swarmName, currentAgentName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function commitSystemMessage";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function commitSystemMessage", {
+                    swarm.loggerService.log(METHOD_NAME$k, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, "commitSystemMessage");
-                swarm.sessionValidationService.validate(clientId, "commitSystemMessage");
+                swarm.agentValidationService.validate(agentName, METHOD_NAME$k);
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$k);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "commitSystemMessage");
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$k);
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$k, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -7619,7 +7639,7 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.commitSystemMessage(content, methodName, clientId, swarmName)];
+                return [4 /*yield*/, swarm.sessionPublicService.commitSystemMessage(content, METHOD_NAME$k, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -7627,6 +7647,7 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
     });
 }); };
 
+var METHOD_NAME$j = "function.commitFlush";
 /**
  * Commits flush of agent history
  *
@@ -7635,21 +7656,20 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
  * @returns {Promise<void>} - A promise that resolves when the message is committed.
  */
 var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName, currentAgentName;
+    var swarmName, currentAgentName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function commitFlush";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function commitFlush", {
+                    swarm.loggerService.log(METHOD_NAME$j, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, "commitFlush");
-                swarm.sessionValidationService.validate(clientId, "commitFlush");
+                swarm.agentValidationService.validate(agentName, METHOD_NAME$j);
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$j);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "commitFlush");
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$j);
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$j, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -7661,7 +7681,7 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.commitFlush(methodName, clientId, swarmName)];
+                return [4 /*yield*/, swarm.sessionPublicService.commitFlush(METHOD_NAME$j, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -7669,6 +7689,7 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
     });
 }); };
 
+var METHOD_NAME$i = "function.execute";
 /**
  * Send the message to the active agent in the swarm content like it income from client side
  * Should be used to review tool output and initiate conversation from the model side to client
@@ -7679,25 +7700,23 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
  * @returns {Promise<void>} - A promise that resolves when the execution is complete.
  */
 var execute = function (content, clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, executionId, swarmName, currentAgentName;
+    var executionId, swarmName, currentAgentName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function execute";
                 executionId = functoolsKit.randomString();
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function execute", {
+                    swarm.loggerService.log(METHOD_NAME$i, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
-                        methodName: methodName,
                         executionId: executionId,
                     });
-                swarm.agentValidationService.validate(agentName, "execute");
-                swarm.sessionValidationService.validate(clientId, "execute");
+                swarm.agentValidationService.validate(agentName, METHOD_NAME$i);
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$i);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "execute");
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$i);
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -7712,7 +7731,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", methodName, clientId, swarmName)];
+                                case 0: return [4 /*yield*/, swarm.sessionPublicService.execute(content, "tool", METHOD_NAME$i, clientId, swarmName)];
                                 case 1: return [2 /*return*/, _a.sent()];
                             }
                         });
@@ -7724,6 +7743,7 @@ var execute = function (content, clientId, agentName) { return __awaiter(void 0,
     });
 }); };
 
+var METHOD_NAME$h = "function.emit";
 /**
  * Emits a string constant as the model output without executing incoming message
  * Works only for `makeConnection`
@@ -7735,13 +7755,12 @@ var execute = function (content, clientId, agentName) { return __awaiter(void 0,
  * @returns {Promise<void>} A promise that resolves when the content is emitted.
  */
 var emit = function (content, clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName, currentAgentName;
+    var swarmName, currentAgentName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function emit";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function emit", {
+                    swarm.loggerService.log(METHOD_NAME$h, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
@@ -7749,11 +7768,11 @@ var emit = function (content, clientId, agentName) { return __awaiter(void 0, vo
                 if (swarm.sessionValidationService.getSessionMode(clientId) !== "makeConnection") {
                     throw new Error("agent-swarm-kit emit session is not makeConnection clientId=".concat(clientId));
                 }
-                swarm.agentValidationService.validate(agentName, "emit");
-                swarm.sessionValidationService.validate(clientId, "emit");
+                swarm.agentValidationService.validate(agentName, METHOD_NAME$h);
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$h);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "emit");
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$h);
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$h, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -7765,12 +7784,13 @@ var emit = function (content, clientId, agentName) { return __awaiter(void 0, vo
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.sessionPublicService.emit(content, methodName, clientId, swarmName)];
+                return [4 /*yield*/, swarm.sessionPublicService.emit(content, METHOD_NAME$h, clientId, swarmName)];
             case 2: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
 
+var METHOD_NAME$g = "function.commitToolOutputForce";
 /**
  * Commits the tool output to the active agent in a swarm session without checking active agent
  *
@@ -7779,21 +7799,20 @@ var emit = function (content, clientId, agentName) { return __awaiter(void 0, vo
  * @returns {Promise<void>} - A promise that resolves when the operation is complete.
  */
 var commitToolOutputForce = function (toolId, content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName;
+    var swarmName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function commitToolOutputForce";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function commitToolOutputForce", {
+                    swarm.loggerService.log(METHOD_NAME$g, {
                         toolId: toolId,
                         content: content,
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, "commitToolOutputForce");
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$g);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "commitToolOutputForce");
-                return [4 /*yield*/, swarm.sessionPublicService.commitToolOutput(toolId, content, methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$g);
+                return [4 /*yield*/, swarm.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$g, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -7801,6 +7820,7 @@ var commitToolOutputForce = function (toolId, content, clientId) { return __awai
     });
 }); };
 
+var METHOD_NAME$f = "function.commitSystemMessageForce";
 /**
  * Commits a system message to the active agent in as swarm without checking active agent.
  *
@@ -7809,20 +7829,19 @@ var commitToolOutputForce = function (toolId, content, clientId) { return __awai
  * @returns {Promise<void>} - A promise that resolves when the message is committed.
  */
 var commitSystemMessageForce = function (content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName;
+    var swarmName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function commitSystemMessageForce";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function commitSystemMessageForce", {
+                    swarm.loggerService.log(METHOD_NAME$f, {
                         content: content,
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, "commitSystemMessageForce");
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$f);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "commitSystemMessageForce");
-                return [4 /*yield*/, swarm.sessionPublicService.commitSystemMessage(content, methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$f);
+                return [4 /*yield*/, swarm.sessionPublicService.commitSystemMessage(content, METHOD_NAME$f, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -7830,6 +7849,7 @@ var commitSystemMessageForce = function (content, clientId) { return __awaiter(v
     });
 }); };
 
+var METHOD_NAME$e = "function.commitFlushForce";
 /**
  * Commits flush of agent history without active agent check
  *
@@ -7837,20 +7857,19 @@ var commitSystemMessageForce = function (content, clientId) { return __awaiter(v
  * @returns {Promise<void>} - A promise that resolves when the message is committed.
  */
 var commitFlushForce = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName;
+    var swarmName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function commitFlushForce";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function commitFlushForce", {
+                    swarm.loggerService.log(METHOD_NAME$e, {
                         clientId: clientId,
-                        methodName: methodName,
+                        METHOD_NAME: METHOD_NAME$e,
                     });
-                swarm.sessionValidationService.validate(clientId, "commitFlushForce");
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$e);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "commitFlushForce");
-                return [4 /*yield*/, swarm.sessionPublicService.commitFlush(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$e);
+                return [4 /*yield*/, swarm.sessionPublicService.commitFlush(METHOD_NAME$e, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -7858,6 +7877,7 @@ var commitFlushForce = function (clientId) { return __awaiter(void 0, void 0, vo
     });
 }); };
 
+var METHOD_NAME$d = "function.commitSystemMessage";
 /**
  * Commits a user message to the active agent history in as swarm without answer and checking active agent
  *
@@ -7866,20 +7886,19 @@ var commitFlushForce = function (clientId) { return __awaiter(void 0, void 0, vo
  * @returns {Promise<void>} - A promise that resolves when the message is committed.
  */
 var commitUserMessageForce = function (content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName;
+    var swarmName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function commitSystemMessage";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function commitSystemMessage", {
+                    swarm.loggerService.log(METHOD_NAME$d, {
                         content: content,
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, "commitUserMessageForce");
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$d);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "commitUserMessageForce");
-                return [4 /*yield*/, swarm.sessionPublicService.commitUserMessage(content, methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$d);
+                return [4 /*yield*/, swarm.sessionPublicService.commitUserMessage(content, METHOD_NAME$d, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -7887,6 +7906,7 @@ var commitUserMessageForce = function (content, clientId) { return __awaiter(voi
     });
 }); };
 
+var METHOD_NAME$c = "function.emitForce";
 /**
  * Emits a string constant as the model output without executing incoming message and checking active agent
  * Works only for `makeConnection`
@@ -7898,28 +7918,28 @@ var commitUserMessageForce = function (content, clientId) { return __awaiter(voi
  * @returns {Promise<void>} A promise that resolves when the content is emitted.
  */
 var emitForce = function (content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName;
+    var swarmName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function emitForce";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function emitForce", {
+                    swarm.loggerService.log(METHOD_NAME$c, {
                         content: content,
                         clientId: clientId,
                     });
                 if (swarm.sessionValidationService.getSessionMode(clientId) !== "makeConnection") {
                     throw new Error("agent-swarm-kit emitForce session is not makeConnection clientId=".concat(clientId));
                 }
-                swarm.sessionValidationService.validate(clientId, "emitForce");
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$c);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "emitForce");
-                return [4 /*yield*/, swarm.sessionPublicService.emit(content, methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$c);
+                return [4 /*yield*/, swarm.sessionPublicService.emit(content, METHOD_NAME$c, clientId, swarmName)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
 
+var METHOD_NAME$b = "function.executeForce";
 /**
  * Send the message to the active agent in the swarm content like it income from client side
  * Should be used to review tool output and initiate conversation from the model side to client
@@ -7931,23 +7951,22 @@ var emitForce = function (content, clientId) { return __awaiter(void 0, void 0,
  * @returns {Promise<void>} - A promise that resolves when the execution is complete.
  */
 var executeForce = function (content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, executionId, swarmName;
+    var executionId, swarmName;
     return __generator(this, function (_a) {
-        methodName = "function executeForce";
         executionId = functoolsKit.randomString();
         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-            swarm.loggerService.log("function executeForce", {
+            swarm.loggerService.log(METHOD_NAME$b, {
                 content: content,
                 clientId: clientId,
                 executionId: executionId,
             });
-        swarm.sessionValidationService.validate(clientId, "executeForce");
+        swarm.sessionValidationService.validate(clientId, METHOD_NAME$b);
         swarmName = swarm.sessionValidationService.getSwarm(clientId);
-        swarm.swarmValidationService.validate(swarmName, "executeForce");
+        swarm.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", methodName, clientId, swarmName)];
+                        case 0: return [4 /*yield*/, swarm.sessionPublicService.execute(content, "tool", METHOD_NAME$b, clientId, swarmName)];
                         case 1: return [2 /*return*/, _a.sent()];
                     }
                 });
@@ -7958,6 +7977,7 @@ var executeForce = function (content, clientId) { return __awaiter(void 0, void
     });
 }); };
 
+var METHOD_NAME$a = "function.listenEvent";
 var DISALLOWED_EVENT_SOURCE_LIST$2 = new Set([
     "agent-bus",
     "history-bus",
@@ -7983,7 +8003,7 @@ var validateClientId$d = function (clientId) {
  */
 var listenEvent = function (clientId, topicName, fn) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function listenEvent", {
+        swarm.loggerService.log(METHOD_NAME$a, {
             clientId: clientId,
         });
     if (DISALLOWED_EVENT_SOURCE_LIST$2.has(topicName)) {
@@ -7996,6 +8016,7 @@ var listenEvent = function (clientId, topicName, fn) {
     });
 };
 
+var METHOD_NAME$9 = "function.listenEventOnce";
 var DISALLOWED_EVENT_SOURCE_LIST$1 = new Set([
     "agent-bus",
     "history-bus",
@@ -8021,7 +8042,7 @@ var validateClientId$c = function (clientId) {
  */
 var listenEventOnce = function (clientId, topicName, filterFn, fn) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function listenEventOnce", {
+        swarm.loggerService.log(METHOD_NAME$9, {
             clientId: clientId,
         });
     if (DISALLOWED_EVENT_SOURCE_LIST$1.has(topicName)) {
@@ -8037,6 +8058,7 @@ var listenEventOnce = function (clientId, topicName, filterFn, fn) {
     });
 };
 
+var METHOD_NAME$8 = "function.getLastUserMessage";
 /**
  * Retrieves the last message sent by the user from the client's message history.
  *
@@ -8044,16 +8066,15 @@ var listenEventOnce = function (clientId, topicName, filterFn, fn) {
  * @returns {Promise<string | null>} - The content of the last user message, or null if no user message is found.
  */
 var getLastUserMessage = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, history, last;
+    var history, last;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function getLastUserMessage";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function getLastUserMessage", {
+                    swarm.loggerService.log(METHOD_NAME$8, {
                         clientId: clientId,
                     });
-                return [4 /*yield*/, getRawHistory(clientId, methodName)];
+                return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$8)];
             case 1:
                 history = _a.sent();
                 last = history.findLast(function (_a) {
@@ -8065,6 +8086,7 @@ var getLastUserMessage = function (clientId) { return __awaiter(void 0, void 0,
     });
 }); };
 
+var METHOD_NAME$7 = "function.getUserHistory";
 /**
  * Retrieves the user history for a given client ID.
  *
@@ -8072,16 +8094,15 @@ var getLastUserMessage = function (clientId) { return __awaiter(void 0, void 0,
  * @returns {Promise<Array>} A promise that resolves to an array of history objects filtered by user role.
  */
 var getUserHistory = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, history;
+    var history;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function getUserHistory";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function getUserHistory", {
+                    swarm.loggerService.log(METHOD_NAME$7, {
                         clientId: clientId,
                     });
-                return [4 /*yield*/, getRawHistory(clientId, methodName)];
+                return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$7)];
             case 1:
                 history = _a.sent();
                 return [2 /*return*/, history.filter(function (_a) {
@@ -8092,6 +8113,7 @@ var getUserHistory = function (clientId) { return __awaiter(void 0, void 0, void
     });
 }); };
 
+var METHOD_NAME$6 = "function.getAssistantHistory";
 /**
  * Retrieves the assistant's history for a given client.
  *
@@ -8099,16 +8121,15 @@ var getUserHistory = function (clientId) { return __awaiter(void 0, void 0, void
  * @returns {Promise<Array>} - A promise that resolves to an array of history objects where the role is "assistant".
  */
 var getAssistantHistory = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, history;
+    var history;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function getAssistantHistory";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function getAssistantHistory", {
+                    swarm.loggerService.log(METHOD_NAME$6, {
                         clientId: clientId,
                     });
-                return [4 /*yield*/, getRawHistory(clientId, methodName)];
+                return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$6)];
             case 1:
                 history = _a.sent();
                 return [2 /*return*/, history.filter(function (_a) {
@@ -8119,6 +8140,7 @@ var getAssistantHistory = function (clientId) { return __awaiter(void 0, void 0,
     });
 }); };
 
+var METHOD_NAME$5 = "function.getLastAssistantMessage";
 /**
  * Retrieves the last message sent by the assistant from the client's message history.
  *
@@ -8126,16 +8148,15 @@ var getAssistantHistory = function (clientId) { return __awaiter(void 0, void 0,
  * @returns {Promise<string | null>} - The content of the last assistant message, or null if no user message is found.
  */
 var getLastAssistantMessage = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, history, last;
+    var history, last;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function getLastAssistantMessage";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function getLastAssistantMessage", {
+                    swarm.loggerService.log(METHOD_NAME$5, {
                         clientId: clientId,
                     });
-                return [4 /*yield*/, getRawHistory(clientId, methodName)];
+                return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$5)];
             case 1:
                 history = _a.sent();
                 last = history.findLast(function (_a) {
@@ -8147,6 +8168,7 @@ var getLastAssistantMessage = function (clientId) { return __awaiter(void 0, voi
     });
 }); };
 
+var METHOD_NAME$4 = "function.getLastSystemMessage";
 /**
  * Retrieves the last message sent by the system from the client's message history.
  *
@@ -8154,16 +8176,15 @@ var getLastAssistantMessage = function (clientId) { return __awaiter(void 0, voi
  * @returns {Promise<string | null>} - The content of the last system message, or null if no user message is found.
  */
 var getLastSystemMessage = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, history, last;
+    var history, last;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function getLastSystemMessage";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function getLastSystemMessage", {
+                    swarm.loggerService.log(METHOD_NAME$4, {
                         clientId: clientId,
                     });
-                return [4 /*yield*/, getRawHistory(clientId, methodName)];
+                return [4 /*yield*/, getRawHistory(clientId, METHOD_NAME$4)];
             case 1:
                 history = _a.sent();
                 last = history.findLast(function (_a) {
@@ -8175,6 +8196,7 @@ var getLastSystemMessage = function (clientId) { return __awaiter(void 0, void 0
     });
 }); };
 
+var METHOD_NAME$3 = "function.makeAutoDispose";
 var DEFAULT_TIMEOUT = 15 * 60;
 /**
  * Creates an auto-dispose mechanism for a client in a swarm.
@@ -8187,7 +8209,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("function makeAutoDispose", {
+        swarm.loggerService.log(METHOD_NAME$3, {
             clientId: clientId,
             swarmName: swarmName,
         });
@@ -8234,6 +8256,7 @@ var makeAutoDispose = function (clientId, swarmName, _a) {
     };
 };
 
+var METHOD_NAME$2 = "function.listenEvent";
 var DISALLOWED_EVENT_SOURCE_LIST = new Set([
     "agent-bus",
     "history-bus",
@@ -8252,7 +8275,7 @@ var DISALLOWED_EVENT_SOURCE_LIST = new Set([
  */
 var event = function (clientId, topicName, payload) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm.loggerService.log("function listenEvent", {
+        swarm.loggerService.log(METHOD_NAME$2, {
             clientId: clientId,
         });
     if (DISALLOWED_EVENT_SOURCE_LIST.has(topicName)) {
@@ -8265,6 +8288,7 @@ var event = function (clientId, topicName, payload) {
     });
 };
 
+var METHOD_NAME$1 = "function.cancelOutput";
 /**
  * Cancel the await of output by emit of empty string
  *
@@ -8273,21 +8297,20 @@ var event = function (clientId, topicName, payload) {
  * @returns {Promise<void>} - A promise that resolves when the output is canceled
  */
 var cancelOutput = function (clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName, currentAgentName;
+    var swarmName, currentAgentName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function cancelOutput";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function cancelOutput", {
+                    swarm.loggerService.log(METHOD_NAME$1, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm.agentValidationService.validate(agentName, "cancelOutput");
-                swarm.sessionValidationService.validate(clientId, "cancelOutput");
+                swarm.agentValidationService.validate(agentName, METHOD_NAME$1);
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME$1);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "cancelOutput");
-                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME$1);
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(METHOD_NAME$1, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -8299,7 +8322,7 @@ var cancelOutput = function (clientId, agentName) { return __awaiter(void 0, voi
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm.swarmPublicService.cancelOutput(methodName, clientId, swarmName)];
+                return [4 /*yield*/, swarm.swarmPublicService.cancelOutput(METHOD_NAME$1, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -8307,6 +8330,7 @@ var cancelOutput = function (clientId, agentName) { return __awaiter(void 0, voi
     });
 }); };
 
+var METHOD_NAME = "function.cancelOutputForce";
 /**
  * Cancel the await of output by emit of empty string without checking active agent
  *
@@ -8315,19 +8339,18 @@ var cancelOutput = function (clientId, agentName) { return __awaiter(void 0, voi
  * @returns {Promise<void>} - A promise that resolves when the output is canceled
  */
 var cancelOutputForce = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var methodName, swarmName;
+    var swarmName;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                methodName = "function cancelOutputForce";
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm.loggerService.log("function cancelOutputForce", {
+                    swarm.loggerService.log(METHOD_NAME, {
                         clientId: clientId,
                     });
-                swarm.sessionValidationService.validate(clientId, "cancelOutputForce");
+                swarm.sessionValidationService.validate(clientId, METHOD_NAME);
                 swarmName = swarm.sessionValidationService.getSwarm(clientId);
-                swarm.swarmValidationService.validate(swarmName, "cancelOutputForce");
-                return [4 /*yield*/, swarm.swarmPublicService.cancelOutput(methodName, clientId, swarmName)];
+                swarm.swarmValidationService.validate(swarmName, METHOD_NAME);
+                return [4 /*yield*/, swarm.swarmPublicService.cancelOutput(METHOD_NAME, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -8599,6 +8622,12 @@ var listenSwarmEventOnce = function (clientId, filterFn, fn) {
     return swarm.busService.once(clientId, "swarm-bus", filterFn, fn);
 };
 
+var METHOD_NAME_TAKE = "StorageUtils.take";
+var METHOD_NAME_UPSERT = "StorageUtils.upsert";
+var METHOD_NAME_REMOVE = "StorageUtils.remove";
+var METHOD_NAME_GET$1 = "StorageUtils.get";
+var METHOD_NAME_LIST = "StorageUtils.list";
+var METHOD_NAME_CLEAR = "StorageUtils.clear";
 var StorageUtils = /** @class */ (function () {
     function StorageUtils() {
         var _this = this;
@@ -8613,24 +8642,22 @@ var StorageUtils = /** @class */ (function () {
          * @template T
          */
         this.take = function (payload) { return __awaiter(_this, void 0, void 0, function () {
-            var methodName;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        methodName = "StorageUtils take";
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("StorageUtils take", {
+                            swarm.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, "StorageUtils");
+                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_TAKE);
                         if (!swarm.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, methodName, payload.clientId, payload.storageName, payload.score)];
+                        return [4 /*yield*/, swarm.storagePublicService.take(payload.search, payload.total, METHOD_NAME_TAKE, payload.clientId, payload.storageName, payload.score)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
@@ -8645,22 +8672,20 @@ var StorageUtils = /** @class */ (function () {
          * @template T
          */
         this.upsert = function (payload) { return __awaiter(_this, void 0, void 0, function () {
-            var methodName;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        methodName = "StorageUtils upsert";
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("StorageUtils upsert", {
+                            swarm.loggerService.log(METHOD_NAME_UPSERT, {
                                 item: payload.item,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, "StorageUtils");
+                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_UPSERT);
                         if (!swarm.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, methodName, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm.storagePublicService.upsert(payload.item, METHOD_NAME_UPSERT, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8674,22 +8699,20 @@ var StorageUtils = /** @class */ (function () {
          * @returns {Promise<void>} - A promise that resolves when the operation is complete.
          */
         this.remove = function (payload) { return __awaiter(_this, void 0, void 0, function () {
-            var methodName;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        methodName = "StorageUtils remove";
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("StorageUtils remove", {
+                            swarm.loggerService.log(METHOD_NAME_REMOVE, {
                                 itemId: payload.itemId,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, "StorageUtils");
+                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_REMOVE);
                         if (!swarm.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, methodName, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm.storagePublicService.remove(payload.itemId, METHOD_NAME_REMOVE, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8704,22 +8727,20 @@ var StorageUtils = /** @class */ (function () {
          * @template T
          */
         this.get = function (payload) { return __awaiter(_this, void 0, void 0, function () {
-            var methodName;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        methodName = "StorageUtils get";
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("StorageUtils get", {
+                            swarm.loggerService.log(METHOD_NAME_GET$1, {
                                 itemId: payload.itemId,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, "StorageUtils");
+                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_GET$1);
                         if (!swarm.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, methodName, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm.storagePublicService.get(payload.itemId, METHOD_NAME_GET$1, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
@@ -8734,21 +8755,19 @@ var StorageUtils = /** @class */ (function () {
          * @template T
          */
         this.list = function (payload) { return __awaiter(_this, void 0, void 0, function () {
-            var methodName;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        methodName = "StorageUtils list";
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("StorageUtils list", {
+                            swarm.loggerService.log(METHOD_NAME_LIST, {
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, "StorageUtils");
+                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_LIST);
                         if (!swarm.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(methodName, payload.clientId, payload.storageName, payload.filter)];
+                        return [4 /*yield*/, swarm.storagePublicService.list(METHOD_NAME_LIST, payload.clientId, payload.storageName, payload.filter)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
@@ -8761,21 +8780,19 @@ var StorageUtils = /** @class */ (function () {
          * @returns {Promise<void>} - A promise that resolves when the operation is complete.
          */
         this.clear = function (payload) { return __awaiter(_this, void 0, void 0, function () {
-            var methodName;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        methodName = "StorageUtils clear";
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("StorageUtils clear", {
+                            swarm.loggerService.log(METHOD_NAME_CLEAR, {
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm.storageValidationService.validate(payload.storageName, "StorageUtils");
+                        swarm.storageValidationService.validate(payload.storageName, METHOD_NAME_CLEAR);
                         if (!swarm.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(methodName, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm.storagePublicService.clear(METHOD_NAME_CLEAR, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8785,6 +8802,8 @@ var StorageUtils = /** @class */ (function () {
 }());
 var Storage = new StorageUtils();
 
+var METHOD_NAME_GET = "StateUtils.getState";
+var METHOD_NAME_SET = "StateUtils.setState";
 /**
  * Utility class for managing state in the agent swarm.
  * @implements {TState}
@@ -8803,20 +8822,18 @@ var StateUtils = /** @class */ (function () {
          * @throws Will throw an error if the state is not registered in the agent.
          */
         this.getState = function (payload) { return __awaiter(_this, void 0, void 0, function () {
-            var methodName;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        methodName = "StateUtils getState";
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("StateUtils getState", {
+                            swarm.loggerService.log(METHOD_NAME_GET, {
                                 clientId: payload.clientId,
                                 stateName: payload.stateName,
                             });
                         if (!swarm.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(methodName, payload.clientId, payload.stateName)];
+                        return [4 /*yield*/, swarm.statePublicService.getState(METHOD_NAME_GET, payload.clientId, payload.stateName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8833,14 +8850,12 @@ var StateUtils = /** @class */ (function () {
          * @throws Will throw an error if the state is not registered in the agent.
          */
         this.setState = function (dispatchFn, payload) { return __awaiter(_this, void 0, void 0, function () {
-            var methodName;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        methodName = "StateUtils setState";
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm.loggerService.log("StateUtils setState", {
+                            swarm.loggerService.log(METHOD_NAME_SET, {
                                 clientId: payload.clientId,
                                 stateName: payload.stateName,
                             });
@@ -8848,11 +8863,11 @@ var StateUtils = /** @class */ (function () {
                             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, methodName, payload.clientId, payload.stateName)];
+                        return [4 /*yield*/, swarm.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) {
                             return [2 /*return*/, dispatchFn];
-                        }); }); }, methodName, payload.clientId, payload.stateName)];
+                        }); }); }, METHOD_NAME_SET, payload.clientId, payload.stateName)];
                     case 3: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -8866,6 +8881,7 @@ var StateUtils = /** @class */ (function () {
  */
 var State = new StateUtils();
 
+var METHOD_NAME_USE_LOGGER = "HistoryInstance.useLogger";
 var LoggerUtils = /** @class */ (function () {
     function LoggerUtils() {
         /**
@@ -8874,7 +8890,7 @@ var LoggerUtils = /** @class */ (function () {
          */
         this.useLogger = function (logger) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm.loggerService.log("HistoryInstance useLogger");
+                swarm.loggerService.log(METHOD_NAME_USE_LOGGER);
             swarm.loggerService.setLogger(logger);
         };
     }
@@ -8920,6 +8936,7 @@ var objectFlat = function (data) {
 };
 
 var LIST_SEPARATOR = Array.from({ length: 80 }, function () { return "-"; });
+var METHOD_NAME_SERIALIZE = "SchemaUtils.serialize";
 /**
  * Utility class for schema-related operations.
  */
@@ -8934,7 +8951,7 @@ var SchemaUtils = /** @class */ (function () {
          */
         this.serialize = function (data) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                swarm.loggerService.log("SchemaUtils serialize", {
+                swarm.loggerService.log(METHOD_NAME_SERIALIZE, {
                     data: data,
                 });
             if (Array.isArray(data)) {