agent-swarm-kit 1.0.113 → 1.0.115

package/build/index.cjs

@@ -199,6 +199,7 @@ var schemaServices$1 = {
     embeddingSchemaService: Symbol('embeddingSchemaService'),
     storageSchemaService: Symbol('storageSchemaService'),
     stateSchemaService: Symbol('stateSchemaService'),
+    memorySchemaService: Symbol('memorySchemaService'),
 };
 var metaServices$1 = {
     agentMetaService: Symbol('agentMetaService'),
@@ -2352,6 +2353,85 @@ var ClientAgent = /** @class */ (function () {
                 }
             });
         }); });
+        /**
+         * Run the completion stateless and return the output
+         * @param {string} incoming - The incoming message content.
+         * @returns {Promise<void>}
+         */
+        this.run = functoolsKit.queued(function (incoming) { return __awaiter(_this, void 0, void 0, function () {
+            var messages, args, rawMessage, message, result, validation;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                            this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " clientId=").concat(this.params.clientId, " run begin"), { incoming: incoming });
+                        this.params.onRun &&
+                            this.params.onRun(this.params.clientId, this.params.agentName, incoming);
+                        return [4 /*yield*/, this.params.history.toArrayForAgent(this.params.prompt, this.params.system)];
+                    case 1:
+                        messages = _d.sent();
+                        messages.push({
+                            agentName: this.params.agentName,
+                            content: incoming,
+                            mode: "user",
+                            role: "assistant",
+                        });
+                        args = {
+                            clientId: this.params.clientId,
+                            agentName: this.params.agentName,
+                            messages: messages,
+                            mode: "user",
+                            tools: (_a = this.params.tools) === null || _a === void 0 ? void 0 : _a.map(function (t) {
+                                return lodashEs.omit(t, "toolName", "docNote", "call", "validate", "callbacks");
+                            }),
+                        };
+                        return [4 /*yield*/, this.params.completion.getCompletion(args)];
+                    case 2:
+                        rawMessage = _d.sent();
+                        ((_b = this.params.completion.callbacks) === null || _b === void 0 ? void 0 : _b.onComplete) &&
+                            ((_c = this.params.completion.callbacks) === null || _c === void 0 ? void 0 : _c.onComplete(args, rawMessage));
+                        return [4 /*yield*/, this.params.map(rawMessage, this.params.clientId, this.params.agentName)];
+                    case 3:
+                        message = _d.sent();
+                        return [4 /*yield*/, this.params.transform(message.content, this.params.clientId, this.params.agentName)];
+                    case 4:
+                        result = _d.sent();
+                        return [4 /*yield*/, this.params.bus.emit(this.params.clientId, {
+                                type: "run",
+                                source: "agent-bus",
+                                input: {
+                                    message: message,
+                                },
+                                output: {
+                                    result: result,
+                                },
+                                context: {
+                                    agentName: this.params.agentName,
+                                },
+                                clientId: this.params.clientId,
+                            })];
+                    case 5:
+                        _d.sent();
+                        if (message.tool_calls) {
+                            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                                this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " clientId=").concat(this.params.clientId, " run should not call tools"), { incoming: incoming, result: result });
+                            return [2 /*return*/, ""];
+                        }
+                        validation = null;
+                        return [4 /*yield*/, this.params.validate(result)];
+                    case 6:
+                        if ((validation = _d.sent())) {
+                            GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                                this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " clientId=").concat(this.params.clientId, " run validation not passed: ").concat(validation), { incoming: incoming, result: result });
+                            return [2 /*return*/, ""];
+                        }
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                            this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " clientId=").concat(this.params.clientId, " run end result=").concat(result));
+                        return [2 /*return*/, result];
+                }
+            });
+        }); });
         /**
          * Should call on agent dispose
          * @returns {Promise<void>}
@@ -2434,6 +2514,24 @@ var AgentConnectionService = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Run the completion stateless
+         * @param {string} input - The input command.
+         * @returns {Promise<any>} The execution result.
+         */
+        this.run = function (input) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("agentConnectionService run", {
+                                input: input,
+                            });
+                        return [4 /*yield*/, this.getAgent(this.methodContextService.context.clientId, this.methodContextService.context.agentName).run(input)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         /**
          * Waits for the output from the agent.
          * @returns {Promise<any>} The output result.
@@ -3734,6 +3832,48 @@ var ClientSession = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Run the completion stateless
+         * @param {string} message - The message to run.
+         * @returns {Promise<string>} - The output of the execution.
+         */
+        this.run = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            var agent, output;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                            this.params.logger.debug("ClientSession clientId=".concat(this.params.clientId, " run"), {
+                                message: message,
+                            });
+                        this.params.onRun &&
+                            this.params.onRun(this.params.clientId, this.params.swarmName, message);
+                        return [4 /*yield*/, this.params.swarm.getAgent()];
+                    case 1:
+                        agent = _a.sent();
+                        return [4 /*yield*/, agent.run(message)];
+                    case 2:
+                        output = _a.sent();
+                        return [4 /*yield*/, this.params.bus.emit(this.params.clientId, {
+                                type: "run",
+                                source: "session-bus",
+                                input: {
+                                    message: message,
+                                },
+                                output: {
+                                    result: output,
+                                },
+                                context: {
+                                    swarmName: this.params.swarmName,
+                                },
+                                clientId: this.params.clientId,
+                            })];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/, output];
+                }
+            });
+        }); };
         /**
          * Commits tool output.
          * @param {string} toolId - The `tool_call_id` for openai history
@@ -4106,6 +4246,24 @@ var SessionConnectionService = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Run the completion stateless
+         * @param {string} content - The content to execute.
+         * @returns {Promise<string>} A promise that resolves with the execution result.
+         */
+        this.run = function (content) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sessionConnectionService run", {
+                                content: content,
+                            });
+                        return [4 /*yield*/, this.getSession(this.methodContextService.context.clientId, this.methodContextService.context.swarmName).run(content)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         /**
          * Connects to the session using the provided connector.
          * @param {SendMessageFn} connector - The function to send messages.
@@ -4332,6 +4490,44 @@ var AgentPublicService = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Run the completion stateless
+         * @param {string} input - The input command.
+         * @param {string} clientId - The client ID.
+         * @param {AgentName} agentName - The name of the agent.
+         * @returns {Promise<unknown>} The execution result.
+         */
+        this.run = function (input, methodName, clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("agentPublicService run", {
+                                methodName: methodName,
+                                input: input,
+                                clientId: clientId,
+                                agentName: agentName,
+                            });
+                        return [4 /*yield*/, MethodContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.agentConnectionService.run(input)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                                storageName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         /**
          * Waits for the agent's output.
          * @param {string} clientId - The client ID.
@@ -4912,6 +5108,43 @@ var SessionPublicService = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Run the completion stateless
+         * @param {string} content - The content to execute.
+         * @param {string} clientId - The client ID.
+         * @param {SwarmName} swarmName - The swarm name.
+         * @returns {Promise<void>}
+         */
+        this.run = function (content, methodName, clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sessionPublicService run", {
+                                content: content,
+                                clientId: clientId,
+                                swarmName: swarmName,
+                            });
+                        return [4 /*yield*/, MethodContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.sessionConnectionService.run(content)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                                storageName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         /**
          * Connects to the session.
          * @param {SendMessageFn} connector - The function to send messages.
@@ -9180,6 +9413,63 @@ var SharedStoragePublicService = /** @class */ (function () {
     return SharedStoragePublicService;
 }());
 
+/**
+ * Service to manage memory schema for different sessions.
+ */
+var MemorySchemaService = /** @class */ (function () {
+    function MemorySchemaService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.memoryMap = new Map();
+        /**
+         * Writes a value to the memory map for a given client ID.
+         *
+         * @template T - The type of the value to be written.
+         * @param {string} clientId - The ID of the client.
+         * @param {T} value - The value to be written.
+         */
+        this.writeValue = function (clientId, value) {
+            var _a;
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                _this.loggerService.info("memorySchemaService setValue", {
+                    clientId: clientId,
+                    value: value,
+                });
+            var pendingValue = Object.assign((_a = _this.memoryMap.get(clientId)) !== null && _a !== void 0 ? _a : {}, value);
+            _this.memoryMap.set(clientId, pendingValue);
+            return pendingValue;
+        };
+        /**
+         * Reads a value from the memory map for a given client ID.
+         *
+         * @template T - The type of the value to be read.
+         * @param {string} clientId - The ID of the client.
+         * @returns {T} - The value associated with the client ID.
+         */
+        this.readValue = function (clientId) {
+            var _a;
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                _this.loggerService.info("memorySchemaService getValue", {
+                    clientId: clientId,
+                });
+            return ((_a = _this.memoryMap.get(clientId)) !== null && _a !== void 0 ? _a : {});
+        };
+        /**
+         * Disposes the memory map entry for a given client ID.
+         *
+         * @param {string} clientId - The ID of the client.
+         */
+        this.dispose = function (clientId) {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                _this.loggerService.info("memorySchemaService dispose", {
+                    clientId: clientId,
+                });
+            _this.memoryMap.delete(clientId);
+        };
+    }
+    return MemorySchemaService;
+}());
+
 {
     provide(TYPES.docService, function () { return new DocService(); });
     provide(TYPES.busService, function () { return new BusService(); });
@@ -9207,6 +9497,7 @@ var SharedStoragePublicService = /** @class */ (function () {
     provide(TYPES.embeddingSchemaService, function () { return new EmbeddingSchemaService(); });
     provide(TYPES.storageSchemaService, function () { return new StorageSchemaService(); });
     provide(TYPES.stateSchemaService, function () { return new StateSchemaService(); });
+    provide(TYPES.memorySchemaService, function () { return new MemorySchemaService(); });
 }
 {
     provide(TYPES.agentPublicService, function () { return new AgentPublicService(); });
@@ -9259,6 +9550,7 @@ var schemaServices = {
     embeddingSchemaService: inject(TYPES.embeddingSchemaService),
     storageSchemaService: inject(TYPES.storageSchemaService),
     stateSchemaService: inject(TYPES.stateSchemaService),
+    memorySchemaService: inject(TYPES.memorySchemaService),
 };
 var publicServices = {
     agentPublicService: inject(TYPES.agentPublicService),
@@ -9287,7 +9579,7 @@ var swarm = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, b
 init();
 var swarm$1 = swarm;
 
-var METHOD_NAME$L = "cli.dumpDocs";
+var METHOD_NAME$O = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -9298,7 +9590,7 @@ var METHOD_NAME$L = "cli.dumpDocs";
 var dumpDocs = function (dirName, PlantUML) {
     if (dirName === void 0) { dirName = "./docs/chat"; }
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$L, {
+        swarm$1.loggerService.log(METHOD_NAME$O, {
             dirName: dirName,
         });
     if (PlantUML) {
@@ -9309,12 +9601,12 @@ var dumpDocs = function (dirName, PlantUML) {
     swarm$1.agentValidationService
         .getAgentList()
         .forEach(function (agentName) {
-        return swarm$1.agentValidationService.validate(agentName, METHOD_NAME$L);
+        return swarm$1.agentValidationService.validate(agentName, METHOD_NAME$O);
     });
     swarm$1.swarmValidationService
         .getSwarmList()
         .forEach(function (swarmName) {
-        return swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$L);
+        return swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$O);
     });
     swarm$1.agentValidationService.getAgentList().forEach(function (agentName) {
         var dependsOn = swarm$1.agentSchemaService.get(agentName).dependsOn;
@@ -9325,7 +9617,7 @@ var dumpDocs = function (dirName, PlantUML) {
     return swarm$1.docService.dumpDocs(dirName);
 };
 
-var METHOD_NAME$K = "cli.dumpAgent";
+var METHOD_NAME$N = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -9335,14 +9627,14 @@ var METHOD_NAME$K = "cli.dumpAgent";
 var dumpAgent = function (agentName, _a) {
     var _b = _a === void 0 ? {} : _a, _c = _b.withSubtree, withSubtree = _c === void 0 ? false : _c;
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$K, {
+        swarm$1.loggerService.log(METHOD_NAME$N, {
             agentName: agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$K);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$N);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 };
 
-var METHOD_NAME$J = "cli.dumpSwarm";
+var METHOD_NAME$M = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -9351,14 +9643,14 @@ var METHOD_NAME$J = "cli.dumpSwarm";
  */
 var dumpSwarm = function (swarmName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$J, {
+        swarm$1.loggerService.log(METHOD_NAME$M, {
             swarmName: swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$M);
     return swarm$1.swarmMetaService.toUML(swarmName);
 };
 
-var METHOD_NAME$I = "function.addAgent";
+var METHOD_NAME$L = "function.setup.addAgent";
 /**
  * Adds a new agent to the agent registry. The swarm takes only those agents which was registered
  *
@@ -9367,7 +9659,7 @@ var METHOD_NAME$I = "function.addAgent";
  */
 var addAgent = function (agentSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$I, {
+        swarm$1.loggerService.log(METHOD_NAME$L, {
             agentSchema: agentSchema,
         });
     swarm$1.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
@@ -9375,7 +9667,7 @@ var addAgent = function (agentSchema) {
     return agentSchema.agentName;
 };
 
-var METHOD_NAME$H = "function.addCompletion";
+var METHOD_NAME$K = "function.setup.addCompletion";
 /**
  * Adds a completion engine for agents. Agents could use different models and
  * framewords for completion like: mock, gpt4all, ollama, openai
@@ -9385,7 +9677,7 @@ var METHOD_NAME$H = "function.addCompletion";
  */
 var addCompletion = function (completionSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$H, {
+        swarm$1.loggerService.log(METHOD_NAME$K, {
             completionSchema: completionSchema,
         });
     swarm$1.completionValidationService.addCompletion(completionSchema.completionName);
@@ -9393,7 +9685,7 @@ var addCompletion = function (completionSchema) {
     return completionSchema.completionName;
 };
 
-var METHOD_NAME$G = "function.addSwarm";
+var METHOD_NAME$J = "function.setup.addSwarm";
 /**
  * Adds a new swarm to the system. The swarm is a root for starting client session
  *
@@ -9402,7 +9694,7 @@ var METHOD_NAME$G = "function.addSwarm";
  */
 var addSwarm = function (swarmSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$G, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             swarmSchema: swarmSchema,
         });
     swarm$1.swarmValidationService.addSwarm(swarmSchema.swarmName, swarmSchema);
@@ -9410,7 +9702,7 @@ var addSwarm = function (swarmSchema) {
     return swarmSchema.swarmName;
 };
 
-var METHOD_NAME$F = "function.addTool";
+var METHOD_NAME$I = "function.setup.addTool";
 /**
  * Adds a new tool for agents in a swarm. Tool should be registered in `addAgent`
  * declaration
@@ -9420,7 +9712,7 @@ var METHOD_NAME$F = "function.addTool";
  */
 var addTool = function (toolSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             toolSchema: toolSchema,
         });
     swarm$1.toolValidationService.addTool(toolSchema.toolName, toolSchema);
@@ -9428,7 +9720,7 @@ var addTool = function (toolSchema) {
     return toolSchema.toolName;
 };
 
-var METHOD_NAME$E = "function.addState";
+var METHOD_NAME$H = "function.setup.addState";
 /**
  * Adds a new state to the state registry. The swarm takes only those states which was registered
  *
@@ -9437,7 +9729,7 @@ var METHOD_NAME$E = "function.addState";
  */
 var addState = function (stateSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             stateSchema: stateSchema,
         });
     swarm$1.stateSchemaService.register(stateSchema.stateName, stateSchema);
@@ -9449,7 +9741,7 @@ var addState = function (stateSchema) {
     return stateSchema.stateName;
 };
 
-var METHOD_NAME$D = "function.addEmbedding";
+var METHOD_NAME$G = "function.setup.addEmbedding";
 /**
  * Adds a new embedding to the embedding registry. The swarm takes only those embeddings which was registered
  *
@@ -9458,7 +9750,7 @@ var METHOD_NAME$D = "function.addEmbedding";
  */
 var addEmbedding = function (embeddingSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             embeddingSchema: embeddingSchema,
         });
     swarm$1.embeddingValidationService.addEmbedding(embeddingSchema.embeddingName, embeddingSchema);
@@ -9466,7 +9758,7 @@ var addEmbedding = function (embeddingSchema) {
     return embeddingSchema.embeddingName;
 };
 
-var METHOD_NAME$C = "function.addStorage";
+var METHOD_NAME$F = "function.setup.addStorage";
 /**
  * Adds a new storage to the storage registry. The swarm takes only those storages which was registered
  *
@@ -9475,7 +9767,7 @@ var METHOD_NAME$C = "function.addStorage";
  */
 var addStorage = function (storageSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             storageSchema: storageSchema,
         });
     swarm$1.storageValidationService.addStorage(storageSchema.storageName, storageSchema);
@@ -9488,7 +9780,7 @@ var addStorage = function (storageSchema) {
     return storageSchema.storageName;
 };
 
-var METHOD_NAME$B = "function.commitToolOutput";
+var METHOD_NAME$E = "function.commit.commitToolOutput";
 /**
  * Commits the tool output to the active agent in a swarm session
  *
@@ -9503,17 +9795,17 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$B, {
+                    swarm$1.loggerService.log(METHOD_NAME$E, {
                         toolId: toolId,
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$E);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$E);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$E);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$E, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -9526,7 +9818,7 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$B, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$E, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -9534,7 +9826,7 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
     });
 }); };
 
-var METHOD_NAME$A = "function.commitSystemMessage";
+var METHOD_NAME$D = "function.commit.commitSystemMessage";
 /**
  * Commits a system message to the active agent in the swarm.
  *
@@ -9549,16 +9841,16 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$A, {
+                    swarm$1.loggerService.log(METHOD_NAME$D, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$A);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$D);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$D);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$A, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$D);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$D, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -9570,7 +9862,7 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$A, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$D, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -9578,7 +9870,7 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
     });
 }); };
 
-var METHOD_NAME$z = "function.commitFlush";
+var METHOD_NAME$C = "function.commit.commitFlush";
 /**
  * Commits flush of agent history
  *
@@ -9592,15 +9884,15 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$z, {
+                    swarm$1.loggerService.log(METHOD_NAME$C, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$C);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$C);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$C);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$C, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -9612,7 +9904,7 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$z, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$C, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -9620,7 +9912,7 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
     });
 }); };
 
-var METHOD_NAME$y = "function.commitSystemMessage";
+var METHOD_NAME$B = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent history in as swarm without answer.
  *
@@ -9635,16 +9927,16 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$y, {
+                    swarm$1.loggerService.log(METHOD_NAME$B, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$y);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$B);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$B);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$y, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$B);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$B, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -9656,7 +9948,7 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$y, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$B, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -9664,7 +9956,7 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
     });
 }); };
 
-var METHOD_NAME$x = "function.commitToolOutputForce";
+var METHOD_NAME$A = "function.commit.commitToolOutputForce";
 /**
  * Commits the tool output to the active agent in a swarm session without checking active agent
  *
@@ -9678,15 +9970,15 @@ var commitToolOutputForce = function (toolId, content, clientId) { return __awai
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$x, {
+                    swarm$1.loggerService.log(METHOD_NAME$A, {
                         toolId: toolId,
                         content: content,
                         clientId: clientId,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$A);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$x, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$A);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$A, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -9694,7 +9986,7 @@ var commitToolOutputForce = function (toolId, content, clientId) { return __awai
     });
 }); };
 
-var METHOD_NAME$w = "function.commitSystemMessageForce";
+var METHOD_NAME$z = "function.commit.commitSystemMessageForce";
 /**
  * Commits a system message to the active agent in as swarm without checking active agent.
  *
@@ -9708,14 +10000,14 @@ var commitSystemMessageForce = function (content, clientId) { return __awaiter(v
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$w, {
+                    swarm$1.loggerService.log(METHOD_NAME$z, {
                         content: content,
                         clientId: clientId,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$w, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$z, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -9723,7 +10015,7 @@ var commitSystemMessageForce = function (content, clientId) { return __awaiter(v
     });
 }); };
 
-var METHOD_NAME$v = "function.commitFlushForce";
+var METHOD_NAME$y = "function.commit.commitFlushForce";
 /**
  * Commits flush of agent history without active agent check
  *
@@ -9736,14 +10028,14 @@ var commitFlushForce = function (clientId) { return __awaiter(void 0, void 0, vo
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$v, {
+                    swarm$1.loggerService.log(METHOD_NAME$y, {
                         clientId: clientId,
-                        METHOD_NAME: METHOD_NAME$v,
+                        METHOD_NAME: METHOD_NAME$y,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$v, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$y, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -9751,7 +10043,7 @@ var commitFlushForce = function (clientId) { return __awaiter(void 0, void 0, vo
     });
 }); };
 
-var METHOD_NAME$u = "function.commitSystemMessage";
+var METHOD_NAME$x = "function.commit.commitSystemMessage";
 /**
  * Commits a user message to the active agent history in as swarm without answer and checking active agent
  *
@@ -9765,14 +10057,14 @@ var commitUserMessageForce = function (content, clientId) { return __awaiter(voi
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$u, {
+                    swarm$1.loggerService.log(METHOD_NAME$x, {
                         content: content,
                         clientId: clientId,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$u, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$x, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -9780,7 +10072,7 @@ var commitUserMessageForce = function (content, clientId) { return __awaiter(voi
     });
 }); };
 
-var METHOD_NAME$t = "function.commitAssistantMessage";
+var METHOD_NAME$w = "function.commit.commitAssistantMessage";
 /**
  * Commits an assistant message to the active agent in the swarm.
  *
@@ -9795,16 +10087,16 @@ var commitAssistantMessage = function (content, clientId, agentName) { return __
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$t, {
+                    swarm$1.loggerService.log(METHOD_NAME$w, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$t);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$w);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$t, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$w, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -9816,7 +10108,7 @@ var commitAssistantMessage = function (content, clientId, agentName) { return __
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$t, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$w, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -9824,7 +10116,7 @@ var commitAssistantMessage = function (content, clientId, agentName) { return __
     });
 }); };
 
-var METHOD_NAME$s = "function.commitAssistantMessageForce";
+var METHOD_NAME$v = "function.commit.commitAssistantMessageForce";
 /**
  * Commits an assistant message to the active agent in as swarm without checking active agent.
  *
@@ -9838,14 +10130,14 @@ var commitAssistantMessageForce = function (content, clientId) { return __awaite
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$s, {
+                    swarm$1.loggerService.log(METHOD_NAME$v, {
                         content: content,
                         clientId: clientId,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$s, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$v, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -9853,7 +10145,7 @@ var commitAssistantMessageForce = function (content, clientId) { return __awaite
     });
 }); };
 
-var METHOD_NAME$r = "function.cancelOutput";
+var METHOD_NAME$u = "function.commit.cancelOutput";
 /**
  * Cancel the await of output by emit of empty string
  *
@@ -9867,15 +10159,15 @@ var cancelOutput = function (clientId, agentName) { return __awaiter(void 0, voi
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$r, {
+                    swarm$1.loggerService.log(METHOD_NAME$u, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$r);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$u);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$r, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -9887,7 +10179,7 @@ var cancelOutput = function (clientId, agentName) { return __awaiter(void 0, voi
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$r, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$u, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -9895,7 +10187,7 @@ var cancelOutput = function (clientId, agentName) { return __awaiter(void 0, voi
     });
 }); };
 
-var METHOD_NAME$q = "function.cancelOutputForce";
+var METHOD_NAME$t = "function.commit.cancelOutputForce";
 /**
  * Cancel the await of output by emit of empty string without checking active agent
  *
@@ -9909,13 +10201,13 @@ var cancelOutputForce = function (clientId) { return __awaiter(void 0, void 0, v
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$q, {
+                    swarm$1.loggerService.log(METHOD_NAME$t, {
                         clientId: clientId,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
-                return [4 /*yield*/, swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$q, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
+                return [4 /*yield*/, swarm$1.swarmPublicService.cancelOutput(METHOD_NAME$t, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -9923,7 +10215,7 @@ var cancelOutputForce = function (clientId) { return __awaiter(void 0, void 0, v
     });
 }); };
 
-var METHOD_NAME$p = "function.commitStopTools";
+var METHOD_NAME$s = "function.commit.commitStopTools";
 /**
  * Prevent the next tool from being executed
  *
@@ -9937,15 +10229,15 @@ var commitStopTools = function (clientId, agentName) { return __awaiter(void 0,
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$p, {
+                    swarm$1.loggerService.log(METHOD_NAME$s, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$p);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$p);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$p, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -9957,7 +10249,7 @@ var commitStopTools = function (clientId, agentName) { return __awaiter(void 0,
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$p, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$s, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -9965,7 +10257,7 @@ var commitStopTools = function (clientId, agentName) { return __awaiter(void 0,
     });
 }); };
 
-var METHOD_NAME$o = "function.commitStopToolsForce";
+var METHOD_NAME$r = "function.commit.commitStopToolsForce";
 /**
  * Prevent the next tool from being executed without active agent check
  *
@@ -9978,14 +10270,14 @@ var commitStopToolsForce = function (clientId) { return __awaiter(void 0, void 0
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$o, {
+                    swarm$1.loggerService.log(METHOD_NAME$r, {
                         clientId: clientId,
-                        METHOD_NAME: METHOD_NAME$o,
+                        METHOD_NAME: METHOD_NAME$r,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$o);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$o);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$o, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitStopTools(METHOD_NAME$r, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -9993,7 +10285,7 @@ var commitStopToolsForce = function (clientId) { return __awaiter(void 0, void 0
     });
 }); };
 
-var METHOD_NAME$n = "function.emitForce";
+var METHOD_NAME$q = "function.target.emitForce";
 /**
  * Emits a string constant as the model output without executing incoming message and checking active agent
  * Works only for `makeConnection`
@@ -10010,23 +10302,23 @@ var emitForce = function (content, clientId) { return __awaiter(void 0, void 0,
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$n, {
+                    swarm$1.loggerService.log(METHOD_NAME$q, {
                         content: content,
                         clientId: clientId,
                     });
                 if (swarm$1.sessionValidationService.getSessionMode(clientId) !== "makeConnection") {
                     throw new Error("agent-swarm-kit emitForce session is not makeConnection clientId=".concat(clientId));
                 }
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$n);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$n);
-                return [4 /*yield*/, swarm$1.sessionPublicService.emit(content, METHOD_NAME$n, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
+                return [4 /*yield*/, swarm$1.sessionPublicService.emit(content, METHOD_NAME$q, clientId, swarmName)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
 
-var METHOD_NAME$m = "function.executeForce";
+var METHOD_NAME$p = "function.target.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
@@ -10042,18 +10334,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$1.loggerService.log(METHOD_NAME$m, {
+            swarm$1.loggerService.log(METHOD_NAME$p, {
                 content: content,
                 clientId: clientId,
                 executionId: executionId,
             });
-        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$p);
         swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-        swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
+        swarm$1.swarmValidationService.validate(swarmName, 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$1.sessionPublicService.execute(content, "tool", METHOD_NAME$m, clientId, swarmName)];
+                        case 0: return [4 /*yield*/, swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$p, clientId, swarmName)];
                         case 1: return [2 /*return*/, _a.sent()];
                     }
                 });
@@ -10064,7 +10356,7 @@ var executeForce = function (content, clientId) { return __awaiter(void 0, void
     });
 }); };
 
-var METHOD_NAME$l = "function.disposeConnection";
+var METHOD_NAME$o = "function.target.disposeConnection";
 /**
  * Disposes the session for a given client with all related swarms and agents.
  *
@@ -10078,12 +10370,12 @@ 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 = METHOD_NAME$l; }
+        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$1.loggerService.log(METHOD_NAME$l, {
+                        swarm$1.loggerService.log(METHOD_NAME$o, {
                             clientId: clientId,
                             swarmName: swarmName,
                         });
@@ -10157,13 +10449,14 @@ var disposeConnection = function (clientId_1, swarmName_1) {
                     swarm$1.sessionValidationService.removeSession(clientId);
                     swarm$1.busService.dispose(clientId);
                     swarm$1.sessionValidationService.dispose(clientId);
+                    swarm$1.memorySchemaService.dispose(clientId);
                     return [2 /*return*/];
             }
         });
     });
 };
 
-var METHOD_NAME$k = "function.makeAutoDispose";
+var METHOD_NAME$n = "function.target.makeAutoDispose";
 var DEFAULT_TIMEOUT = 15 * 60;
 /**
  * Creates an auto-dispose mechanism for a client in a swarm.
@@ -10176,7 +10469,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$1.loggerService.log(METHOD_NAME$k, {
+        swarm$1.loggerService.log(METHOD_NAME$n, {
             clientId: clientId,
             swarmName: swarmName,
         });
@@ -10223,7 +10516,7 @@ var makeAutoDispose = function (clientId, swarmName, _a) {
     };
 };
 
-var METHOD_NAME$j = "function.execute";
+var METHOD_NAME$m = "function.target.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
@@ -10240,17 +10533,17 @@ var execute = function (content, clientId, agentName) { return __awaiter(void 0,
             case 0:
                 executionId = functoolsKit.randomString();
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$j, {
+                    swarm$1.loggerService.log(METHOD_NAME$m, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                         executionId: executionId,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$j);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$m);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$m);
                 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)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$m);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$m, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -10265,7 +10558,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$1.sessionPublicService.execute(content, "tool", METHOD_NAME$j, clientId, swarmName)];
+                                case 0: return [4 /*yield*/, swarm$1.sessionPublicService.execute(content, "tool", METHOD_NAME$m, clientId, swarmName)];
                                 case 1: return [2 /*return*/, _a.sent()];
                             }
                         });
@@ -10277,7 +10570,7 @@ var execute = function (content, clientId, agentName) { return __awaiter(void 0,
     });
 }); };
 
-var METHOD_NAME$i = "function.emit";
+var METHOD_NAME$l = "function.target.emit";
 /**
  * Emits a string constant as the model output without executing incoming message
  * Works only for `makeConnection`
@@ -10294,7 +10587,7 @@ var emit = function (content, clientId, agentName) { return __awaiter(void 0, vo
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$i, {
+                    swarm$1.loggerService.log(METHOD_NAME$l, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
@@ -10302,11 +10595,11 @@ var emit = function (content, clientId, agentName) { return __awaiter(void 0, vo
                 if (swarm$1.sessionValidationService.getSessionMode(clientId) !== "makeConnection") {
                     throw new Error("agent-swarm-kit emit session is not makeConnection clientId=".concat(clientId));
                 }
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$i);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
+                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$i);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName)];
+                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) {
@@ -10318,13 +10611,105 @@ var emit = function (content, clientId, agentName) { return __awaiter(void 0, vo
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.emit(content, METHOD_NAME$i, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.emit(content, METHOD_NAME$l, clientId, swarmName)];
             case 2: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
 
-var METHOD_NAME$h = "function.getAgentName";
+var METHOD_NAME$k = "function.target.run";
+/**
+ * Complete the message stateless without append to the chat history
+ * Use to prevent model from history overflow while handling storage output
+ *
+ * @param {string} content - The content to be runned.
+ * @param {string} clientId - The ID of the client requesting run.
+ * @param {AgentName} agentName - The name of the agent running the command.
+  * @returns {Promise<string>} - A promise that resolves the run result
+ */
+var run = function (content, clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
+    var executionId, swarmName, currentAgentName;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                executionId = functoolsKit.randomString();
+                GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                    swarm$1.loggerService.log(METHOD_NAME$k, {
+                        content: content,
+                        clientId: clientId,
+                        agentName: agentName,
+                        executionId: executionId,
+                    });
+                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$1.loggerService.log('function "run" skipped due to the agent change', {
+                            currentAgentName: currentAgentName,
+                            agentName: agentName,
+                            clientId: clientId,
+                        });
+                    return [2 /*return*/];
+                }
+                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$1.sessionPublicService.run(content, METHOD_NAME$k, clientId, swarmName)];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        });
+                    }); }, {
+                        clientId: clientId,
+                        executionId: executionId,
+                    })];
+        }
+    });
+}); };
+
+var METHOD_NAME$j = "function.target.runForce";
+/**
+ * Complete the message stateless without append to the chat history
+ * Use to prevent model from history overflow while handling storage output
+ *
+ * Will run even if the agent is inactive
+ *
+ * @param {string} content - The content to be runned.
+ * @param {string} clientId - The ID of the client requesting run.
+ * @returns {Promise<string>} - A promise that resolves the run result
+ */
+var runForce = function (content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
+    var executionId, swarmName;
+    return __generator(this, function (_a) {
+        executionId = functoolsKit.randomString();
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log(METHOD_NAME$j, {
+                content: content,
+                clientId: clientId,
+                executionId: executionId,
+            });
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$j);
+        swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+        swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$j);
+        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$1.sessionPublicService.run(content, METHOD_NAME$j, clientId, swarmName)];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                });
+            }); }, {
+                clientId: clientId,
+                executionId: executionId,
+            })];
+    });
+}); };
+
+var METHOD_NAME$i = "function.common.getAgentName";
 /**
  * Retrieves the agent name for a given client ID.
  *
@@ -10338,20 +10723,20 @@ var getAgentName = function (clientId) { return __awaiter(void 0, void 0, void 0
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$h, {
+                    swarm$1.loggerService.log(METHOD_NAME$i, {
                         clientId: clientId,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$i);
                 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)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$i);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$i, clientId, swarmName)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
 
 var SCHEDULED_DELAY$1 = 1000;
-var METHOD_NAME$g = "function.makeConnection";
+var METHOD_NAME$h = "function.target.makeConnection";
 /**
  * A connection factory for a client to a swarm and returns a function to send messages.
  *
@@ -10362,25 +10747,25 @@ var METHOD_NAME$g = "function.makeConnection";
  */
 var makeConnection = function (connector, clientId, swarmName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$g, {
+        swarm$1.loggerService.log(METHOD_NAME$h, {
             clientId: clientId,
             swarmName: swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$g);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$h);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "makeConnection");
-    var send = swarm$1.sessionPublicService.connect(connector, METHOD_NAME$g, clientId, swarmName);
+    var send = swarm$1.sessionPublicService.connect(connector, METHOD_NAME$h, 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$1.sessionValidationService.validate(clientId, METHOD_NAME$g);
+                    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$h);
                     _a = send;
                     _b = {
                         data: outgoing
                     };
-                    return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$g, clientId, swarmName)];
+                    return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$h, clientId, swarmName)];
                 case 1: return [4 /*yield*/, _a.apply(void 0, [(_b.agentName = _c.sent(),
                             _b.clientId = clientId,
                             _b)])];
@@ -10466,7 +10851,7 @@ makeConnection.scheduled = function (connector, clientId, swarmName, _a) {
     }); };
 };
 
-var METHOD_NAME$f = "function.complete";
+var METHOD_NAME$g = "function.target.complete";
 var COMPLETE_TTL = 15 * 60 * 1000;
 var COMPLETE_GC = 60 * 1000;
 /**
@@ -10526,7 +10911,7 @@ var complete = function (content, clientId, swarmName) { return __awaiter(void 0
             case 0:
                 executionId = functoolsKit.randomString();
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$f, {
+                    swarm$1.loggerService.log(METHOD_NAME$g, {
                         content: content,
                         clientId: clientId,
                         executionId: executionId,
@@ -10539,7 +10924,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(METHOD_NAME$f, content)];
+                                case 0: return [4 /*yield*/, run(METHOD_NAME$g, content)];
                                 case 1: return [2 /*return*/, _a.sent()];
                             }
                         });
@@ -10552,7 +10937,7 @@ var complete = function (content, clientId, swarmName) { return __awaiter(void 0
 }); };
 
 var SCHEDULED_DELAY = 1000;
-var METHOD_NAME$e = "function.session";
+var METHOD_NAME$f = "function.target.session";
 /**
  * Creates a session for the given client and swarm.
  *
@@ -10565,12 +10950,12 @@ var METHOD_NAME$e = "function.session";
 var session = function (clientId, swarmName) {
     var executionId = functoolsKit.randomString();
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$e, {
+        swarm$1.loggerService.log(METHOD_NAME$f, {
             clientId: clientId,
             swarmName: swarmName,
             executionId: executionId,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$e);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$f);
     swarm$1.sessionValidationService.addSession(clientId, swarmName, "session");
     return {
         /**
@@ -10581,11 +10966,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$1.sessionValidationService.validate(clientId, METHOD_NAME$e);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$f);
                 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$1.sessionPublicService.execute(content, "user", METHOD_NAME$e, clientId, swarmName)];
+                                case 0: return [4 /*yield*/, swarm$1.sessionPublicService.execute(content, "user", METHOD_NAME$f, clientId, swarmName)];
                                 case 1: return [2 /*return*/, _a.sent()];
                             }
                         });
@@ -10603,7 +10988,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, METHOD_NAME$e)];
+                    case 0: return [4 /*yield*/, disposeConnection(clientId, swarmName, METHOD_NAME$f)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -10702,7 +11087,7 @@ session.scheduled = function (clientId, swarmName, _a) {
     };
 };
 
-var METHOD_NAME$d = "function.getAgentHistory";
+var METHOD_NAME$e = "function.common.getAgentHistory";
 /**
  * Retrieves the history prepared for a specific agent with resque algorithm tweaks
  *
@@ -10716,13 +11101,14 @@ var getAgentHistory = function (clientId, agentName) { return __awaiter(void 0,
         switch (_a.label) {
             case 0:
                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                    swarm$1.loggerService.log(METHOD_NAME$d, {
+                    swarm$1.loggerService.log(METHOD_NAME$e, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$d);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$e);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$e);
                 prompt = swarm$1.agentSchemaService.get(agentName).prompt;
-                return [4 /*yield*/, swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$d, clientId, agentName)];
+                return [4 /*yield*/, swarm$1.historyPublicService.toArrayForAgent(prompt, METHOD_NAME$e, clientId, agentName)];
             case 1:
                 history = _a.sent();
                 return [2 /*return*/, __spreadArray([], __read(history), false)];
@@ -10730,7 +11116,7 @@ var getAgentHistory = function (clientId, agentName) { return __awaiter(void 0,
     });
 }); };
 
-var METHOD_NAME$c = "function.getSessionMode";
+var METHOD_NAME$d = "function.common.getSessionMode";
 /**
  * Return the session mode (`"session" | "makeConnection" | "complete"`) for clientId
  *
@@ -10740,16 +11126,45 @@ 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$1.loggerService.log(METHOD_NAME$c, {
+            swarm$1.loggerService.log(METHOD_NAME$d, {
                 clientId: clientId,
             });
+        swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$d);
         swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-        swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$c);
+        swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$d);
         return [2 /*return*/, swarm$1.sessionValidationService.getSessionMode(clientId)];
     });
 }); };
 
-var METHOD_NAME$b = "function.getRawHistory";
+var METHOD_NAME$c = "function.common.getSessionContext";
+/**
+ * Retrieves the session context for a given client ID.
+ *
+ * @param {string} clientId - The ID of the client.
+ * @returns {Promise<ISessionContext>} A promise that resolves to the session context.
+ */
+var getSessionContext = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var methodContext, executionContext, clientId;
+    var _a;
+    return __generator(this, function (_b) {
+        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+            swarm$1.loggerService.log(METHOD_NAME$c);
+        methodContext = MethodContextService.hasContext()
+            ? swarm$1.methodContextService.context
+            : null;
+        executionContext = ExecutionContextService.hasContext()
+            ? swarm$1.executionContextService.context
+            : null;
+        clientId = (_a = methodContext === null || methodContext === void 0 ? void 0 : methodContext.clientId) !== null && _a !== void 0 ? _a : executionContext === null || executionContext === void 0 ? void 0 : executionContext.clientId;
+        return [2 /*return*/, {
+                clientId: clientId,
+                methodContext: methodContext,
+                executionContext: executionContext,
+            }];
+    });
+}); };
+
+var METHOD_NAME$b = "function.history.getRawHistory";
 /**
  * Retrieves the raw history as it is for a given client ID without any modifications.
  *
@@ -10786,7 +11201,7 @@ var getRawHistory = function (clientId_1) {
     });
 };
 
-var METHOD_NAME$a = "function.getLastUserMessage";
+var METHOD_NAME$a = "function.history.getLastUserMessage";
 /**
  * Retrieves the last message sent by the user from the client's message history.
  *
@@ -10814,7 +11229,7 @@ var getLastUserMessage = function (clientId) { return __awaiter(void 0, void 0,
     });
 }); };
 
-var METHOD_NAME$9 = "function.getUserHistory";
+var METHOD_NAME$9 = "function.history.getUserHistory";
 /**
  * Retrieves the user history for a given client ID.
  *
@@ -10841,7 +11256,7 @@ var getUserHistory = function (clientId) { return __awaiter(void 0, void 0, void
     });
 }); };
 
-var METHOD_NAME$8 = "function.getAssistantHistory";
+var METHOD_NAME$8 = "function.history.getAssistantHistory";
 /**
  * Retrieves the assistant's history for a given client.
  *
@@ -10868,7 +11283,7 @@ var getAssistantHistory = function (clientId) { return __awaiter(void 0, void 0,
     });
 }); };
 
-var METHOD_NAME$7 = "function.getLastAssistantMessage";
+var METHOD_NAME$7 = "function.history.getLastAssistantMessage";
 /**
  * Retrieves the last message sent by the assistant from the client's message history.
  *
@@ -10896,7 +11311,7 @@ var getLastAssistantMessage = function (clientId) { return __awaiter(void 0, voi
     });
 }); };
 
-var METHOD_NAME$6 = "function.getLastSystemMessage";
+var METHOD_NAME$6 = "function.history.getLastSystemMessage";
 /**
  * Retrieves the last message sent by the system from the client's message history.
  *
@@ -10924,7 +11339,7 @@ var getLastSystemMessage = function (clientId) { return __awaiter(void 0, void 0
     });
 }); };
 
-var METHOD_NAME$5 = "function.listenEvent";
+var METHOD_NAME$5 = "function.event.listenEvent";
 var DISALLOWED_EVENT_SOURCE_LIST$2 = new Set([
     "agent-bus",
     "history-bus",
@@ -10956,7 +11371,7 @@ var event = function (clientId, topicName, payload) {
     });
 };
 
-var METHOD_NAME$4 = "function.listenEvent";
+var METHOD_NAME$4 = "function.event.listenEvent";
 var DISALLOWED_EVENT_SOURCE_LIST$1 = new Set([
     "agent-bus",
     "history-bus",
@@ -10989,13 +11404,18 @@ var listenEvent = function (clientId, topicName, fn) {
         throw new Error("agent-swarm listenEvent topic is reserved topicName=".concat(topicName));
     }
     validateClientId$d(clientId);
-    return swarm$1.busService.subscribe(clientId, topicName, function (_a) {
-        var payload = _a.payload;
-        return fn(payload);
-    });
+    return swarm$1.busService.subscribe(clientId, topicName, functoolsKit.queued(function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var payload = _b.payload;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, fn(payload)];
+                case 1: return [2 /*return*/, _c.sent()];
+            }
+        });
+    }); }));
 };
 
-var METHOD_NAME$3 = "function.listenEventOnce";
+var METHOD_NAME$3 = "function.event.listenEventOnce";
 var DISALLOWED_EVENT_SOURCE_LIST = new Set([
     "agent-bus",
     "history-bus",
@@ -11031,13 +11451,18 @@ var listenEventOnce = function (clientId, topicName, filterFn, fn) {
     return swarm$1.busService.once(clientId, topicName, function (_a) {
         var payload = _a.payload;
         return filterFn(payload);
-    }, function (_a) {
-        var payload = _a.payload;
-        return fn(payload);
-    });
+    }, functoolsKit.queued(function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var payload = _b.payload;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, fn(payload)];
+                case 1: return [2 /*return*/, _c.sent()];
+            }
+        });
+    }); }));
 };
 
-var METHOD_NAME$2 = "function.changeToAgent";
+var METHOD_NAME$2 = "function.navigate.changeToAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
  * @constant {number}
@@ -11153,7 +11578,7 @@ var changeToAgent = function (agentName, clientId) { return __awaiter(void 0, vo
     });
 }); };
 
-var METHOD_NAME$1 = "function.changeToPrevAgent";
+var METHOD_NAME$1 = "function.navigate.changeToPrevAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
  * @constant {number}
@@ -11266,7 +11691,7 @@ var changeToPrevAgent = function (clientId) { return __awaiter(void 0, void 0, v
     });
 }); };
 
-var METHOD_NAME = "function.changeToDefaultAgent";
+var METHOD_NAME = "function.navigate.changeToDefaultAgent";
 /**
  * Time-to-live for the change agent function in milliseconds.
  * @constant {number}
@@ -11396,7 +11821,12 @@ var listenAgentEvent = function (clientId, fn) {
         clientId: clientId,
     });
     validateClientId$b(clientId);
-    return swarm$1.busService.subscribe(clientId, "agent-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "agent-bus", functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$a = function (clientId) {
@@ -11418,7 +11848,12 @@ var listenHistoryEvent = function (clientId, fn) {
         clientId: clientId,
     });
     validateClientId$a(clientId);
-    return swarm$1.busService.subscribe(clientId, "history-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "history-bus", functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$9 = function (clientId) {
@@ -11440,7 +11875,12 @@ var listenSessionEvent = function (clientId, fn) {
         clientId: clientId,
     });
     validateClientId$9(clientId);
-    return swarm$1.busService.subscribe(clientId, "session-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "session-bus", functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$8 = function (clientId) {
@@ -11462,7 +11902,12 @@ var listenStateEvent = function (clientId, fn) {
         clientId: clientId,
     });
     validateClientId$8(clientId);
-    return swarm$1.busService.subscribe(clientId, "state-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "state-bus", functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$7 = function (clientId) {
@@ -11484,7 +11929,12 @@ var listenStorageEvent = function (clientId, fn) {
         clientId: clientId,
     });
     validateClientId$7(clientId);
-    return swarm$1.busService.subscribe(clientId, "storage-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "storage-bus", functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$6 = function (clientId) {
@@ -11506,7 +11956,12 @@ var listenSwarmEvent = function (clientId, fn) {
         clientId: clientId,
     });
     validateClientId$6(clientId);
-    return swarm$1.busService.subscribe(clientId, "swarm-bus", fn);
+    return swarm$1.busService.subscribe(clientId, "swarm-bus", functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$5 = function (clientId) {
@@ -11528,7 +11983,12 @@ var listenAgentEventOnce = function (clientId, filterFn, fn) {
         clientId: clientId,
     });
     validateClientId$5(clientId);
-    return swarm$1.busService.once(clientId, "agent-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "agent-bus", filterFn, functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$4 = function (clientId) {
@@ -11550,7 +12010,12 @@ var listenHistoryEventOnce = function (clientId, filterFn, fn) {
         clientId: clientId,
     });
     validateClientId$4(clientId);
-    return swarm$1.busService.once(clientId, "history-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "history-bus", filterFn, functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$3 = function (clientId) {
@@ -11572,7 +12037,12 @@ var listenSessionEventOnce = function (clientId, filterFn, fn) {
         clientId: clientId,
     });
     validateClientId$3(clientId);
-    return swarm$1.busService.once(clientId, "session-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "session-bus", filterFn, functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$2 = function (clientId) {
@@ -11594,7 +12064,12 @@ var listenStateEventOnce = function (clientId, filterFn, fn) {
         clientId: clientId,
     });
     validateClientId$2(clientId);
-    return swarm$1.busService.once(clientId, "state-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "state-bus", filterFn, functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId$1 = function (clientId) {
@@ -11616,7 +12091,12 @@ var listenStorageEventOnce = function (clientId, filterFn, fn) {
         clientId: clientId,
     });
     validateClientId$1(clientId);
-    return swarm$1.busService.once(clientId, "storage-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "storage-bus", filterFn, functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var validateClientId = function (clientId) {
@@ -11638,7 +12118,12 @@ var listenSwarmEventOnce = function (clientId, filterFn, fn) {
         clientId: clientId,
     });
     validateClientId(clientId);
-    return swarm$1.busService.once(clientId, "swarm-bus", filterFn, fn);
+    return swarm$1.busService.once(clientId, "swarm-bus", filterFn, functoolsKit.queued(function (e) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fn(e)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }));
 };
 
 var METHOD_NAME_GET$3 = "StateUtils.getState";
@@ -11765,23 +12250,19 @@ var SharedStateUtils = /** @class */ (function () {
          * Retrieves the state for a given client and state name.
          * @template T
          * @param {Object} payload - The payload containing client and state information.
-         * @param {AgentName} payload.agentName - The agent name.
          * @param {StateName} payload.stateName - The state name.
          * @returns {Promise<T>} The state data.
          * @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 () {
+        this.getState = function (stateName) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
                             swarm$1.loggerService.log(METHOD_NAME_GET$2, {
-                                stateName: payload.stateName,
+                                stateName: stateName,
                             });
-                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
-                            throw new Error("agent-swarm SharedStateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (getSharedState)"));
-                        }
-                        return [4 /*yield*/, swarm$1.sharedStatePublicService.getState(METHOD_NAME_GET$2, payload.stateName)];
+                        return [4 /*yield*/, swarm$1.sharedStatePublicService.getState(METHOD_NAME_GET$2, stateName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -11790,30 +12271,25 @@ var SharedStateUtils = /** @class */ (function () {
          * Sets the state for a given client and state name.
          * @template T
          * @param {T | ((prevSharedState: T) => Promise<T>)} dispatchFn - The new state or a function that returns the new state.
-         * @param {Object} payload - The payload containing client and state information.
-         * @param {AgentName} payload.agentName - The agent name.
-         * @param {StateName} payload.stateName - The state name.
+         * @param {StateName} stateName - The state name.
          * @returns {Promise<void>}
          * @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 () {
+        this.setState = function (dispatchFn, stateName) { return __awaiter(_this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
                             swarm$1.loggerService.log(METHOD_NAME_SET, {
-                                stateName: payload.stateName,
+                                stateName: stateName,
                             });
-                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
-                            throw new Error("agent-swarm SharedStateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (setState)"));
-                        }
                         if (!(typeof dispatchFn === "function")) return [3 /*break*/, 2];
-                        return [4 /*yield*/, swarm$1.sharedStatePublicService.setState(dispatchFn, METHOD_NAME_SET, payload.stateName)];
+                        return [4 /*yield*/, swarm$1.sharedStatePublicService.setState(dispatchFn, METHOD_NAME_SET, stateName)];
                     case 1: return [2 /*return*/, _a.sent()];
                     case 2: return [4 /*yield*/, swarm$1.sharedStatePublicService.setState(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                             return [2 /*return*/, dispatchFn];
-                        }); }); }, METHOD_NAME_SET, payload.stateName)];
+                        }); }); }, METHOD_NAME_SET, stateName)];
                     case 3: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -11821,24 +12297,19 @@ var SharedStateUtils = /** @class */ (function () {
         /**
          * Set the state to initial value
          * @template T
-         * @param {Object} payload - The payload containing client and state information.
-         * @param {AgentName} payload.agentName - The agent name.
          * @param {StateName} payload.stateName - The state name.
          * @returns {Promise<void>}
          * @throws Will throw an error if the state is not registered in the agent.
          */
-        this.clearState = function (payload) { return __awaiter(_this, void 0, void 0, function () {
+        this.clearState = function (stateName) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
                             swarm$1.loggerService.log(METHOD_NAME_SET, {
-                                stateName: payload.stateName,
+                                stateName: stateName,
                             });
-                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
-                            throw new Error("agent-swarm SharedStateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (clearState)"));
-                        }
-                        return [4 /*yield*/, swarm$1.sharedStatePublicService.clearState(METHOD_NAME_CLEAR$2, payload.stateName)];
+                        return [4 /*yield*/, swarm$1.sharedStatePublicService.clearState(METHOD_NAME_CLEAR$2, stateName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -12048,7 +12519,6 @@ var SharedStorageUtils = /** @class */ (function () {
          * Takes items from the storage.
          * @param {string} search - The search query.
          * @param {number} total - The total number of items to take.
-         * @param {AgentName} agentName - The agent name.
          * @param {StorageName} storageName - The storage name.
          * @returns {Promise<T[]>} - A promise that resolves to an array of items.
          * @template T
@@ -12065,9 +12535,6 @@ var SharedStorageUtils = /** @class */ (function () {
                                 score: payload.score,
                             });
                         swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_TAKE);
-                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
-                            throw new Error("agent-swarm SharedStorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (take)"));
-                        }
                         return [4 /*yield*/, swarm$1.sharedStoragePublicService.take(payload.search, payload.total, METHOD_NAME_TAKE, payload.storageName, payload.score)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
@@ -12076,25 +12543,21 @@ var SharedStorageUtils = /** @class */ (function () {
         /**
          * Upserts an item in the storage.
          * @param {T} item - The item to upsert.
-         * @param {AgentName} agentName - The agent name.
          * @param {StorageName} storageName - The storage name.
          * @returns {Promise<void>} - A promise that resolves when the operation is complete.
          * @template T
          */
-        this.upsert = function (payload) { return __awaiter(_this, void 0, void 0, function () {
+        this.upsert = function (item, storageName) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
                             swarm$1.loggerService.log(METHOD_NAME_UPSERT, {
-                                item: payload.item,
-                                storageName: payload.storageName,
+                                item: item,
+                                storageName: storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_UPSERT);
-                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
-                            throw new Error("agent-swarm SharedStorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (upsert)"));
-                        }
-                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.upsert(payload.item, METHOD_NAME_UPSERT, payload.storageName)];
+                        swarm$1.storageValidationService.validate(storageName, METHOD_NAME_UPSERT);
+                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.upsert(item, METHOD_NAME_UPSERT, storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -12102,24 +12565,20 @@ var SharedStorageUtils = /** @class */ (function () {
         /**
          * Removes an item from the storage.
          * @param {IStorageData["id"]} itemId - The ID of the item to remove.
-         * @param {AgentName} agentName - The agent name.
          * @param {StorageName} storageName - The storage name.
          * @returns {Promise<void>} - A promise that resolves when the operation is complete.
          */
-        this.remove = function (payload) { return __awaiter(_this, void 0, void 0, function () {
+        this.remove = function (itemId, storageName) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
                             swarm$1.loggerService.log(METHOD_NAME_REMOVE, {
-                                itemId: payload.itemId,
-                                storageName: payload.storageName,
+                                itemId: itemId,
+                                storageName: storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_REMOVE);
-                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
-                            throw new Error("agent-swarm SharedStorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (remove)"));
-                        }
-                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.remove(payload.itemId, METHOD_NAME_REMOVE, payload.storageName)];
+                        swarm$1.storageValidationService.validate(storageName, METHOD_NAME_REMOVE);
+                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.remove(itemId, METHOD_NAME_REMOVE, storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -12127,73 +12586,61 @@ var SharedStorageUtils = /** @class */ (function () {
         /**
          * Gets an item from the storage.
          * @param {IStorageData["id"]} itemId - The ID of the item to get.
-         * @param {AgentName} agentName - The agent name.
          * @param {StorageName} storageName - The storage name.
          * @returns {Promise<T | null>} - A promise that resolves to the item or null if not found.
          * @template T
          */
-        this.get = function (payload) { return __awaiter(_this, void 0, void 0, function () {
+        this.get = function (itemId, storageName) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
                             swarm$1.loggerService.log(METHOD_NAME_GET, {
-                                itemId: payload.itemId,
-                                storageName: payload.storageName,
+                                itemId: itemId,
+                                storageName: storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_GET);
-                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
-                            throw new Error("agent-swarm SharedStorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (get)"));
-                        }
-                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.get(payload.itemId, METHOD_NAME_GET, payload.storageName)];
+                        swarm$1.storageValidationService.validate(storageName, METHOD_NAME_GET);
+                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.get(itemId, METHOD_NAME_GET, storageName)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
         }); };
         /**
          * Lists items from the storage.
-         * @param {AgentName} agentName - The agent name.
          * @param {StorageName} storageName - The storage name.
          * @param {(item: T) => boolean} [filter] - Optional filter function.
          * @returns {Promise<T[]>} - A promise that resolves to an array of items.
          * @template T
          */
-        this.list = function (payload) { return __awaiter(_this, void 0, void 0, function () {
+        this.list = function (storageName, filter) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
                             swarm$1.loggerService.log(METHOD_NAME_LIST, {
-                                storageName: payload.storageName,
+                                storageName: storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_LIST);
-                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
-                            throw new Error("agent-swarm SharedStorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (list)"));
-                        }
-                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.list(METHOD_NAME_LIST, payload.storageName, payload.filter)];
+                        swarm$1.storageValidationService.validate(storageName, METHOD_NAME_LIST);
+                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.list(METHOD_NAME_LIST, storageName, filter)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
         }); };
         /**
          * Clears the storage.
-         * @param {AgentName} agentName - The agent name.
          * @param {StorageName} storageName - The storage name.
          * @returns {Promise<void>} - A promise that resolves when the operation is complete.
          */
-        this.clear = function (payload) { return __awaiter(_this, void 0, void 0, function () {
+        this.clear = function (storageName) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
                             swarm$1.loggerService.log(METHOD_NAME_CLEAR, {
-                                storageName: payload.storageName,
+                                storageName: storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_CLEAR);
-                        if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
-                            throw new Error("agent-swarm SharedStorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (clear)"));
-                        }
-                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.clear(METHOD_NAME_CLEAR, payload.storageName)];
+                        swarm$1.storageValidationService.validate(storageName, METHOD_NAME_CLEAR);
+                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.clear(METHOD_NAME_CLEAR, storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -12238,11 +12685,44 @@ var objectFlat = function (data) {
 
 var LIST_SEPARATOR = Array.from({ length: 80 }, function () { return "-"; });
 var METHOD_NAME_SERIALIZE = "SchemaUtils.serialize";
+var METHOD_NAME_WRITE = "SchemaUtils.write";
 /**
  * Utility class for schema-related operations.
  */
 var SchemaUtils = /** @class */ (function () {
     function SchemaUtils() {
+        /**
+         * Writes a value to the session memory for a given client.
+         *
+         * @template T - The type of the value to write.
+         * @param {string} clientId - The ID of the client.
+         * @param {T} value - The value to write to the session memory.
+         * @returns {T} The actual value from the session memory.
+         */
+        this.writeSessionMemory = function (clientId, value) {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                swarm$1.loggerService.log(METHOD_NAME_WRITE, {
+                    clientId: clientId,
+                    value: value,
+                });
+            swarm$1.sessionValidationService.validate(clientId, METHOD_NAME_WRITE);
+            return swarm$1.memorySchemaService.writeValue(clientId, value);
+        };
+        /**
+         * Reads a value from the session memory for a given client.
+         *
+         * @template T - The type of the value to read.
+         * @param {string} clientId - The ID of the client.
+         * @returns {T} The value read from the session memory.
+         */
+        this.readSessionMemory = function (clientId) {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                swarm$1.loggerService.log(METHOD_NAME_WRITE, {
+                    clientId: clientId,
+                });
+            swarm$1.sessionValidationService.validate(clientId, METHOD_NAME_WRITE);
+            return swarm$1.memorySchemaService.readValue(clientId);
+        };
         /**
          * Serializes an object or an array of objects into a formatted string.
          *
@@ -12344,6 +12824,7 @@ exports.getLastAssistantMessage = getLastAssistantMessage;
 exports.getLastSystemMessage = getLastSystemMessage;
 exports.getLastUserMessage = getLastUserMessage;
 exports.getRawHistory = getRawHistory;
+exports.getSessionContext = getSessionContext;
 exports.getSessionMode = getSessionMode;
 exports.getUserHistory = getUserHistory;
 exports.listenAgentEvent = listenAgentEvent;
@@ -12362,6 +12843,8 @@ exports.listenSwarmEvent = listenSwarmEvent;
 exports.listenSwarmEventOnce = listenSwarmEventOnce;
 exports.makeAutoDispose = makeAutoDispose;
 exports.makeConnection = makeConnection;
+exports.run = run;
+exports.runForce = runForce;
 exports.session = session;
 exports.setConfig = setConfig;
 exports.swarm = swarm;