agent-swarm-kit 1.0.109 → 1.0.111

package/build/index.cjs

@@ -187,7 +187,9 @@ var connectionServices$1 = {
     swarmConnectionService: Symbol('swarmConnectionService'),
     sessionConnectionService: Symbol('sessionConnectionService'),
     storageConnectionService: Symbol('storageConnectionService'),
+    sharedStorageConnectionService: Symbol('sharedStorageConnectionService'),
     stateConnectionService: Symbol('stateConnectionService'),
+    sharedStateConnectionService: Symbol('sharedStateConnectionService'),
 };
 var schemaServices$1 = {
     completionSchemaService: Symbol('completionSchemaService'),
@@ -208,7 +210,9 @@ var publicServices$1 = {
     sessionPublicService: Symbol('sessionPublicService'),
     swarmPublicService: Symbol('swarmPublicService'),
     storagePublicService: Symbol('storagePublicService'),
+    sharedStoragePublicService: Symbol('sharedStoragePublicService'),
     statePublicService: Symbol('statePublicService'),
+    sharedStatePublicService: Symbol('sharedStatePublicService'),
 };
 var validationServices$1 = {
     agentValidationService: Symbol('agentValidationService'),
@@ -1718,6 +1722,8 @@ var ClientAgent = /** @class */ (function () {
                         }
                         this.params.onOutput &&
                             this.params.onOutput(this.params.clientId, this.params.agentName, result_1);
+                        this.params.onAssistantMessage &&
+                            this.params.onAssistantMessage(this.params.clientId, this.params.agentName, result_1);
                         return [4 /*yield*/, this._outputSubject.next(result_1)];
                     case 6:
                         _a.sent();
@@ -2020,6 +2026,45 @@ var ClientAgent = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Commits an assistant message to the history without execute.
+         * @param {string} message - The system message to commit.
+         * @returns {Promise<void>}
+         */
+        this.commitAssistantMessage = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
+                            this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " clientId=").concat(this.params.clientId, " commitAssistantMessage"), { message: message });
+                        this.params.onAssistantMessage &&
+                            this.params.onAssistantMessage(this.params.clientId, this.params.agentName, message);
+                        return [4 /*yield*/, this.params.history.push({
+                                role: "assistant",
+                                agentName: this.params.agentName,
+                                mode: "tool",
+                                content: message.trim(),
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.params.bus.emit(this.params.clientId, {
+                                type: "commit-assistant-message",
+                                source: "agent-bus",
+                                input: {
+                                    message: message,
+                                },
+                                output: {},
+                                context: {
+                                    agentName: this.params.agentName,
+                                },
+                                clientId: this.params.clientId,
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
         /**
          * Commits the tool output to the history.
          * @param {string} content - The tool output content.
@@ -2386,8 +2431,8 @@ var AgentConnectionService = /** @class */ (function () {
             });
         }); };
         /**
-         * Commits a system message.
-         * @param {string} message - The system message.
+         * Commits an assistant message.
+         * @param {string} message - The assistant message.
          * @returns {Promise<any>} The commit result.
          */
         this.commitSystemMessage = function (message) { return __awaiter(_this, void 0, void 0, function () {
@@ -2403,6 +2448,24 @@ var AgentConnectionService = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Commits a system message.
+         * @param {string} message - The system message.
+         * @returns {Promise<any>} The commit result.
+         */
+        this.commitAssistantMessage = function (message) { 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 commitAssistantMessage", {
+                                message: message,
+                            });
+                        return [4 /*yield*/, this.getAgent(this.methodContextService.context.clientId, this.methodContextService.context.agentName).commitAssistantMessage(message)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         /**
          * Commits a user message without answer.
          * @param {string} message - The message.
@@ -3767,6 +3830,44 @@ var ClientSession = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Commits an assistant message.
+         * @param {string} message - The assistant message to commit.
+         * @returns {Promise<void>}
+         */
+        this.commitAssistantMessage = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            var agent, result;
+            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, " commitAssistantMessage"), {
+                                message: message,
+                            });
+                        return [4 /*yield*/, this.params.swarm.getAgent()];
+                    case 1:
+                        agent = _a.sent();
+                        return [4 /*yield*/, agent.commitAssistantMessage(message)];
+                    case 2:
+                        result = _a.sent();
+                        return [4 /*yield*/, this.params.bus.emit(this.params.clientId, {
+                                type: "commit-assistant-message",
+                                source: "session-bus",
+                                input: {
+                                    message: message,
+                                },
+                                output: {},
+                                context: {
+                                    swarmName: this.params.swarmName,
+                                },
+                                clientId: this.params.clientId,
+                            })];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        }); };
         /**
          * Connects the session to a connector function.
          * @param {SendMessageFn} connector - The connector function.
@@ -3966,6 +4067,24 @@ var SessionConnectionService = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Commits an assistant message to the session.
+         * @param {string} message - The message to commit.
+         * @returns {Promise<void>} A promise that resolves when the message is committed.
+         */
+        this.commitAssistantMessage = function (message) { 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 commitAssistantMessage", {
+                                message: message,
+                            });
+                        return [4 /*yield*/, this.getSession(this.methodContextService.context.clientId, this.methodContextService.context.swarmName).commitAssistantMessage(message)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         /**
          * Commits user message to the agent without answer.
          * @param {string} message - The message to commit.
@@ -4224,6 +4343,44 @@ var AgentPublicService = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Commits an assistant message to the agent history.
+         * @param {string} message - The message to commit.
+         * @param {string} clientId - The client ID.
+         * @param {AgentName} agentName - The name of the agent.
+         * @returns {Promise<unknown>} The commit result.
+         */
+        this.commitAssistantMessage = function (message, 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 commitAssistantMessage", {
+                                methodName: methodName,
+                                message: message,
+                                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.commitAssistantMessage(message)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                                storageName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         /**
          * Commits user message to the agent without answer.
          * @param {string} message - The message to commit.
@@ -4736,6 +4893,44 @@ var SessionPublicService = /** @class */ (function () {
                 }
             });
         }); };
+        /**
+         * Commits an assistant message to the session.
+         * @param {string} message - The message to commit.
+         * @param {string} clientId - The client ID.
+         * @param {SwarmName} swarmName - The swarm name.
+         * @returns {Promise<void>``}
+         */
+        this.commitAssistantMessage = function (message, 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 commitAssistantMessage", {
+                                methodName: methodName,
+                                message: message,
+                                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.commitAssistantMessage(message)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                                storageName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         /**
          * Commits user message to the agent without answer.
          * @param {string} message - The message to commit.
@@ -5664,7 +5859,10 @@ var SessionValidationService = /** @class */ (function () {
          * @param {string} source - The source of the validation request.
          * @throws Will throw an error if the session does not exist.
          */
-        this.validate = function (clientId, source) {
+        this.validate = functoolsKit.memoize(function (_a) {
+            var _b = __read(_a, 1), clientId = _b[0];
+            return "".concat(clientId);
+        }, function (clientId, source) {
             GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
                 _this.loggerService.info("sessionValidationService validate", {
                     clientId: clientId,
@@ -5676,7 +5874,7 @@ var SessionValidationService = /** @class */ (function () {
                 throw new Error("agent-swarm session clientId=".concat(clientId, " not exist source=").concat(source));
             }
             return {};
-        };
+        });
         /**
          * Removes a session.
          * @param {SessionId} clientId - The ID of the client.
@@ -5689,6 +5887,13 @@ var SessionValidationService = /** @class */ (function () {
             _this._sessionSwarmMap.delete(clientId);
             _this._sessionModeMap.delete(clientId);
         };
+        /**
+         * Dispose a session validation cache.
+         * @param {SessionId} clientId - The ID of the client.
+         */
+        this.dispose = function (clientId) {
+            _this.validate.clear(clientId);
+        };
     }
     return SessionValidationService;
 }());
@@ -6314,23 +6519,8 @@ var StorageConnectionService = /** @class */ (function () {
         this.storageSchemaService = inject(TYPES.storageSchemaService);
         this.sessionValidationService = inject(TYPES.sessionValidationService);
         this.embeddingSchemaService = inject(TYPES.embeddingSchemaService);
-        /**
-         * Retrieves a shared storage instance based on storage name.
-         * @param {string} clientId - The client ID.
-         * @param {string} storageName - The storage name.
-         * @returns {ClientStorage} The client storage instance.
-         */
-        this.getSharedStorage = functoolsKit.memoize(function (_a) {
-            var _b = __read(_a, 2), storageName = _b[1];
-            return "".concat(storageName);
-        }, function (clientId, storageName) {
-            var _a = _this.storageSchemaService.get(storageName), createIndex = _a.createIndex, getData = _a.getData, embeddingName = _a.embedding, shared = _a.shared, callbacks = _a.callbacks;
-            var _b = _this.embeddingSchemaService.get(embeddingName), calculateSimilarity = _b.calculateSimilarity, createEmbedding = _b.createEmbedding, embedding = _b.callbacks;
-            if (!shared) {
-                throw new Error("agent-swarm storage not shared storageName=".concat(storageName));
-            }
-            return new ClientStorage(__assign(__assign({ clientId: clientId, storageName: storageName, embedding: embeddingName, calculateSimilarity: calculateSimilarity, createEmbedding: createEmbedding, createIndex: createIndex, getData: getData, shared: shared, logger: _this.loggerService, bus: _this.busService }, embedding), { callbacks: callbacks }));
-        });
+        this.sharedStorageConnectionService = inject(TYPES.sharedStorageConnectionService);
+        this._sharedStorageSet = new Set();
         /**
          * Retrieves a storage instance based on client ID and storage name.
          * @param {string} clientId - The client ID.
@@ -6344,7 +6534,8 @@ var StorageConnectionService = /** @class */ (function () {
             _this.sessionValidationService.addStorageUsage(clientId, storageName);
             var _a = _this.storageSchemaService.get(storageName), createIndex = _a.createIndex, getData = _a.getData, embeddingName = _a.embedding, _b = _a.shared, shared = _b === void 0 ? false : _b, callbacks = _a.callbacks;
             if (shared) {
-                return _this.getSharedStorage(clientId, storageName);
+                _this._sharedStorageSet.add(storageName);
+                return _this.sharedStorageConnectionService.getStorage(storageName);
             }
             var _c = _this.embeddingSchemaService.get(embeddingName), calculateSimilarity = _c.calculateSimilarity, createEmbedding = _c.createEmbedding, embedding = _c.callbacks;
             return new ClientStorage(__assign(__assign({ clientId: clientId, storageName: storageName, embedding: embeddingName, calculateSimilarity: calculateSimilarity, createEmbedding: createEmbedding, createIndex: createIndex, getData: getData, shared: shared, logger: _this.loggerService, bus: _this.busService }, embedding), { callbacks: callbacks }));
@@ -6500,8 +6691,8 @@ var StorageConnectionService = /** @class */ (function () {
                         if (!this.getStorage.has(key)) {
                             return [2 /*return*/];
                         }
-                        if (!!this.getSharedStorage.has(this.methodContextService.context.storageName)) return [3 /*break*/, 3];
-                        storage = this.getSharedStorage(this.methodContextService.context.clientId, this.methodContextService.context.storageName);
+                        if (!!this._sharedStorageSet.has(this.methodContextService.context.storageName)) return [3 /*break*/, 3];
+                        storage = this.getStorage(this.methodContextService.context.clientId, this.methodContextService.context.storageName);
                         return [4 /*yield*/, storage.waitForInit()];
                     case 1:
                         _a.sent();
@@ -7005,33 +7196,36 @@ var ClientState = /** @class */ (function () {
                                 var e_1, _c;
                                 return __generator(this, function (_d) {
                                     switch (_d.label) {
-                                        case 0:
-                                            _d.trys.push([0, 5, 6, 7]);
-                                            _a = __values(this.params.middlewares), _b = _a.next();
-                                            _d.label = 1;
+                                        case 0: return [4 /*yield*/, dispatchFn(currentState)];
                                         case 1:
-                                            if (!!_b.done) return [3 /*break*/, 4];
-                                            middleware = _b.value;
-                                            return [4 /*yield*/, middleware(currentState, this.params.clientId, this.params.stateName)];
-                                        case 2:
                                             currentState = _d.sent();
+                                            _d.label = 2;
+                                        case 2:
+                                            _d.trys.push([2, 7, 8, 9]);
+                                            _a = __values(this.params.middlewares), _b = _a.next();
                                             _d.label = 3;
                                         case 3:
-                                            _b = _a.next();
-                                            return [3 /*break*/, 1];
-                                        case 4: return [3 /*break*/, 7];
+                                            if (!!_b.done) return [3 /*break*/, 6];
+                                            middleware = _b.value;
+                                            return [4 /*yield*/, middleware(currentState, this.params.clientId, this.params.stateName)];
+                                        case 4:
+                                            currentState = _d.sent();
+                                            _d.label = 5;
                                         case 5:
+                                            _b = _a.next();
+                                            return [3 /*break*/, 3];
+                                        case 6: return [3 /*break*/, 9];
+                                        case 7:
                                             e_1_1 = _d.sent();
                                             e_1 = { error: e_1_1 };
-                                            return [3 /*break*/, 7];
-                                        case 6:
+                                            return [3 /*break*/, 9];
+                                        case 8:
                                             try {
                                                 if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                                             }
                                             finally { if (e_1) throw e_1.error; }
                                             return [7 /*endfinally*/];
-                                        case 7: return [4 /*yield*/, dispatchFn(currentState)];
-                                        case 8: return [2 /*return*/, _d.sent()];
+                                        case 9: return [2 /*return*/, currentState];
                                     }
                                 });
                             }); })];
@@ -7136,45 +7330,8 @@ var StateConnectionService = /** @class */ (function () {
         this.methodContextService = inject(TYPES.methodContextService);
         this.stateSchemaService = inject(TYPES.stateSchemaService);
         this.sessionValidationService = inject(TYPES.sessionValidationService);
-        /**
-         * Memoized function to get a shared state reference.
-         * @param {string} clientId - The client ID.
-         * @param {StateName} stateName - The state name.
-         * @returns {ClientState} The client state.
-         */
-        this.getSharedStateRef = functoolsKit.memoize(function (_a) {
-            var _b = __read(_a, 2), stateName = _b[1];
-            return "".concat(stateName);
-        }, function (clientId, stateName) {
-            _this.sessionValidationService.addStateUsage(clientId, stateName);
-            var _a = _this.stateSchemaService.get(stateName), getState = _a.getState, setState = _a.setState, _b = _a.middlewares, middlewares = _b === void 0 ? [] : _b, shared = _a.shared, callbacks = _a.callbacks;
-            if (!shared) {
-                throw new Error("agent-swarm state not shared stateName=".concat(stateName));
-            }
-            return new ClientState({
-                clientId: clientId,
-                stateName: stateName,
-                logger: _this.loggerService,
-                bus: _this.busService,
-                setState: setState
-                    ? functoolsKit.queued(function () {
-                        var args = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            args[_i] = arguments[_i];
-                        }
-                        return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, setState.apply(void 0, __spreadArray([], __read(args), false))];
-                                case 1: return [2 /*return*/, _a.sent()];
-                            }
-                        }); });
-                    })
-                    : setState,
-                getState: getState,
-                middlewares: middlewares,
-                callbacks: callbacks,
-            });
-        });
+        this.sharedStateConnectionService = inject(TYPES.sharedStateConnectionService);
+        this._sharedStateSet = new Set();
         /**
          * Memoized function to get a state reference.
          * @param {string} clientId - The client ID.
@@ -7188,7 +7345,8 @@ var StateConnectionService = /** @class */ (function () {
             _this.sessionValidationService.addStateUsage(clientId, stateName);
             var _a = _this.stateSchemaService.get(stateName), getState = _a.getState, setState = _a.setState, _b = _a.middlewares, middlewares = _b === void 0 ? [] : _b, callbacks = _a.callbacks, _c = _a.shared, shared = _c === void 0 ? false : _c;
             if (shared) {
-                return _this.getSharedStateRef(clientId, stateName);
+                _this._sharedStateSet.add(stateName);
+                return _this.sharedStateConnectionService.getStateRef(stateName);
             }
             return new ClientState({
                 clientId: clientId,
@@ -7270,7 +7428,7 @@ var StateConnectionService = /** @class */ (function () {
                         if (!this.getStateRef.has(key)) {
                             return [2 /*return*/];
                         }
-                        if (!!this.getSharedStateRef.has(this.methodContextService.context.stateName)) return [3 /*break*/, 3];
+                        if (!!this._sharedStateSet.has(this.methodContextService.context.stateName)) return [3 /*break*/, 3];
                         state = this.getStateRef(this.methodContextService.context.clientId, this.methodContextService.context.stateName);
                         return [4 /*yield*/, state.waitForInit()];
                     case 1:
@@ -8130,30 +8288,593 @@ var DocService = /** @class */ (function () {
     return DocService;
 }());
 
-{
-    provide(TYPES.docService, function () { return new DocService(); });
-    provide(TYPES.busService, function () { return new BusService(); });
-    provide(TYPES.loggerService, function () { return new LoggerService(); });
-}
-{
-    provide(TYPES.methodContextService, function () { return new MethodContextService(); });
-    provide(TYPES.executionContextService, function () { return new ExecutionContextService(); });
-}
-{
-    provide(TYPES.agentConnectionService, function () { return new AgentConnectionService(); });
-    provide(TYPES.historyConnectionService, function () { return new HistoryConnectionService(); });
-    provide(TYPES.swarmConnectionService, function () { return new SwarmConnectionService(); });
-    provide(TYPES.sessionConnectionService, function () { return new SessionConnectionService(); });
-    provide(TYPES.storageConnectionService, function () { return new StorageConnectionService(); });
-    provide(TYPES.stateConnectionService, function () { return new StateConnectionService(); });
-}
-{
-    provide(TYPES.agentSchemaService, function () { return new AgentSchemaService(); });
-    provide(TYPES.toolSchemaService, function () { return new ToolSchemaService(); });
-    provide(TYPES.swarmSchemaService, function () { return new SwarmSchemaService(); });
-    provide(TYPES.completionSchemaService, function () { return new CompletionSchemaService(); });
-    provide(TYPES.embeddingSchemaService, function () { return new EmbeddingSchemaService(); });
-    provide(TYPES.storageSchemaService, function () { return new StorageSchemaService(); });
+/**
+ * Service for managing shared state connections.
+ * @template T - The type of state data.
+ * @implements {IState<T>}
+ */
+var SharedStateConnectionService = /** @class */ (function () {
+    function SharedStateConnectionService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.busService = inject(TYPES.busService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.stateSchemaService = inject(TYPES.stateSchemaService);
+        /**
+         * Memoized function to get a shared state reference.
+         * @param {string} clientId - The client ID.
+         * @param {StateName} stateName - The state name.
+         * @returns {ClientState} The client state.
+         */
+        this.getStateRef = functoolsKit.memoize(function (_a) {
+            var _b = __read(_a, 1), stateName = _b[0];
+            return "".concat(stateName);
+        }, function (stateName) {
+            var _a = _this.stateSchemaService.get(stateName), getState = _a.getState, setState = _a.setState, _b = _a.middlewares, middlewares = _b === void 0 ? [] : _b, shared = _a.shared, callbacks = _a.callbacks;
+            if (!shared) {
+                throw new Error("agent-swarm state not shared stateName=".concat(stateName));
+            }
+            return new ClientState({
+                clientId: "*",
+                stateName: stateName,
+                logger: _this.loggerService,
+                bus: _this.busService,
+                setState: setState
+                    ? functoolsKit.queued(function () {
+                        var args = [];
+                        for (var _i = 0; _i < arguments.length; _i++) {
+                            args[_i] = arguments[_i];
+                        }
+                        return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, setState.apply(void 0, __spreadArray([], __read(args), false))];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); });
+                    })
+                    : setState,
+                getState: getState,
+                middlewares: middlewares,
+                callbacks: callbacks,
+            });
+        });
+        /**
+         * Sets the state.
+         * @param {function(T): Promise<T>} dispatchFn - The function to dispatch the new state.
+         * @returns {Promise<T>} The new state.
+         */
+        this.setState = function (dispatchFn) { return __awaiter(_this, void 0, void 0, function () {
+            var state;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sharedStateConnectionService setState");
+                        state = this.getStateRef(this.methodContextService.context.stateName);
+                        return [4 /*yield*/, state.waitForInit()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, state.setState(dispatchFn)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Gets the state.
+         * @returns {Promise<T>} The current state.
+         */
+        this.getState = function () { return __awaiter(_this, void 0, void 0, function () {
+            var state;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sharedStateConnectionService getState");
+                        state = this.getStateRef(this.methodContextService.context.stateName);
+                        return [4 /*yield*/, state.waitForInit()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, state.getState()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return SharedStateConnectionService;
+}());
+
+/**
+ * Service for managing storage connections.
+ * @implements {IStorage}
+ */
+var SharedStorageConnectionService = /** @class */ (function () {
+    function SharedStorageConnectionService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.busService = inject(TYPES.busService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.storageSchemaService = inject(TYPES.storageSchemaService);
+        this.embeddingSchemaService = inject(TYPES.embeddingSchemaService);
+        /**
+         * Retrieves a storage instance based on client ID and storage name.
+         * @param {string} clientId - The client ID.
+         * @param {string} storageName - The storage name.
+         * @returns {ClientStorage} The client storage instance.
+         */
+        this.getStorage = functoolsKit.memoize(function (_a) {
+            var _b = __read(_a, 1), storageName = _b[0];
+            return "".concat(storageName);
+        }, function (storageName) {
+            var _a = _this.storageSchemaService.get(storageName), createIndex = _a.createIndex, getData = _a.getData, embeddingName = _a.embedding, _b = _a.shared, shared = _b === void 0 ? false : _b, callbacks = _a.callbacks;
+            if (!shared) {
+                throw new Error("agent-swarm storage not shared storageName=".concat(storageName));
+            }
+            var _c = _this.embeddingSchemaService.get(embeddingName), calculateSimilarity = _c.calculateSimilarity, createEmbedding = _c.createEmbedding, embedding = _c.callbacks;
+            return new ClientStorage(__assign(__assign({ clientId: "*", storageName: storageName, embedding: embeddingName, calculateSimilarity: calculateSimilarity, createEmbedding: createEmbedding, createIndex: createIndex, getData: getData, shared: shared, logger: _this.loggerService, bus: _this.busService }, embedding), { callbacks: callbacks }));
+        });
+        /**
+         * Retrieves a list of storage data based on a search query and total number of items.
+         * @param {string} search - The search query.
+         * @param {number} total - The total number of items to retrieve.
+         * @returns {Promise<IStorageData[]>} The list of storage data.
+         */
+        this.take = function (search, total, score) { return __awaiter(_this, void 0, void 0, function () {
+            var storage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sharedStorageConnectionService take", {
+                                search: search,
+                                total: total,
+                                score: score,
+                            });
+                        storage = this.getStorage(this.methodContextService.context.storageName);
+                        return [4 /*yield*/, storage.waitForInit()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, storage.take(search, total, score)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Upserts an item in the storage.
+         * @param {IStorageData} item - The item to upsert.
+         * @returns {Promise<void>}
+         */
+        this.upsert = function (item) { return __awaiter(_this, void 0, void 0, function () {
+            var storage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sharedStorageConnectionService upsert", {
+                                item: item,
+                            });
+                        storage = this.getStorage(this.methodContextService.context.storageName);
+                        return [4 /*yield*/, storage.waitForInit()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, storage.upsert(item)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Removes an item from the storage.
+         * @param {IStorageData["id"]} itemId - The ID of the item to remove.
+         * @returns {Promise<void>}
+         */
+        this.remove = function (itemId) { return __awaiter(_this, void 0, void 0, function () {
+            var storage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sharedStorageConnectionService remove", {
+                                itemId: itemId,
+                            });
+                        storage = this.getStorage(this.methodContextService.context.storageName);
+                        return [4 /*yield*/, storage.waitForInit()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, storage.remove(itemId)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Retrieves an item from the storage by its ID.
+         * @param {IStorageData["id"]} itemId - The ID of the item to retrieve.
+         * @returns {Promise<IStorageData>} The retrieved item.
+         */
+        this.get = function (itemId) { return __awaiter(_this, void 0, void 0, function () {
+            var storage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sharedStorageConnectionService get", {
+                                itemId: itemId,
+                            });
+                        storage = this.getStorage(this.methodContextService.context.storageName);
+                        return [4 /*yield*/, storage.waitForInit()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, storage.get(itemId)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Retrieves a list of items from the storage, optionally filtered by a predicate function.
+         * @param {function(IStorageData): boolean} [filter] - The optional filter function.
+         * @returns {Promise<IStorageData[]>} The list of items.
+         */
+        this.list = function (filter) { return __awaiter(_this, void 0, void 0, function () {
+            var storage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sharedStorageConnectionService list");
+                        storage = this.getStorage(this.methodContextService.context.storageName);
+                        return [4 /*yield*/, storage.waitForInit()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, storage.list(filter)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Clears all items from the storage.
+         * @returns {Promise<void>}
+         */
+        this.clear = function () { return __awaiter(_this, void 0, void 0, function () {
+            var storage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                            this.loggerService.info("sharedStorageConnectionService clear");
+                        storage = this.getStorage(this.methodContextService.context.storageName);
+                        return [4 /*yield*/, storage.waitForInit()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, storage.clear()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return SharedStorageConnectionService;
+}());
+
+var SharedStatePublicService = /** @class */ (function () {
+    function SharedStatePublicService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.sharedStateConnectionService = inject(TYPES.sharedStateConnectionService);
+        /**
+         * Sets the state using the provided dispatch function.
+         * @param {function(T): Promise<T>} dispatchFn - The function to dispatch the state change.
+         * @param {StateName} stateName - The name of the state.
+         * @returns {Promise<T>} - The updated state.
+         */
+        this.setState = function (dispatchFn, methodName, 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_INFO &&
+                            this.loggerService.info("sharedStatePublicService setState", {
+                                methodName: methodName,
+                                stateName: stateName,
+                            });
+                        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.sharedStateConnectionService.setState(dispatchFn)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: "",
+                                stateName: stateName,
+                                agentName: "",
+                                swarmName: "",
+                                storageName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Gets the current state.
+         * @param {StateName} stateName - The name of the state.
+         * @returns {Promise<T>} - The current state.
+         */
+        this.getState = function (methodName, 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_INFO &&
+                            this.loggerService.info("sharedStatePublicService getState", {
+                                stateName: stateName,
+                            });
+                        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.sharedStateConnectionService.getState()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: "",
+                                stateName: stateName,
+                                agentName: "",
+                                swarmName: "",
+                                storageName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return SharedStatePublicService;
+}());
+
+/**
+ * Service for managing public storage interactions.
+ */
+var SharedStoragePublicService = /** @class */ (function () {
+    function SharedStoragePublicService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.sharedStorageConnectionService = inject(TYPES.sharedStorageConnectionService);
+        /**
+         * Retrieves a list of storage data based on a search query and total number of items.
+         * @param {string} search - The search query.
+         * @param {number} total - The total number of items to retrieve.
+         * @returns {Promise<IStorageData[]>} The list of storage data.
+         */
+        this.take = function (search, total, methodName, storageName, score) { 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("sharedStoragePublicService take", {
+                                methodName: methodName,
+                                search: search,
+                                total: total,
+                                storageName: storageName,
+                                score: score,
+                            });
+                        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.sharedStorageConnectionService.take(search, total, score)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: "",
+                                storageName: storageName,
+                                agentName: "",
+                                swarmName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Upserts an item in the storage.
+         * @param {IStorageData} item - The item to upsert.
+         * @returns {Promise<void>}
+         */
+        this.upsert = function (item, methodName, storageName) { 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("sharedStoragePublicService upsert", {
+                                item: item,
+                                storageName: storageName,
+                            });
+                        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.sharedStorageConnectionService.upsert(item)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: "",
+                                storageName: storageName,
+                                agentName: "",
+                                swarmName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Removes an item from the storage.
+         * @param {IStorageData["id"]} itemId - The ID of the item to remove.
+         * @returns {Promise<void>}
+         */
+        this.remove = function (itemId, methodName, storageName) { 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("sharedStoragePublicService remove", {
+                                itemId: itemId,
+                                storageName: storageName,
+                            });
+                        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.sharedStorageConnectionService.remove(itemId)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: "",
+                                storageName: storageName,
+                                agentName: "",
+                                swarmName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Retrieves an item from the storage by its ID.
+         * @param {IStorageData["id"]} itemId - The ID of the item to retrieve.
+         * @returns {Promise<IStorageData>} The retrieved item.
+         */
+        this.get = function (itemId, methodName, storageName) { 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("sharedStoragePublicService get", {
+                                methodName: methodName,
+                                itemId: itemId,
+                                storageName: storageName,
+                            });
+                        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.sharedStorageConnectionService.get(itemId)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: "",
+                                storageName: storageName,
+                                agentName: "",
+                                swarmName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Retrieves a list of items from the storage, optionally filtered by a predicate function.
+         * @param {function(IStorageData): boolean} [filter] - The optional filter function.
+         * @returns {Promise<IStorageData[]>} The list of items.
+         */
+        this.list = function (methodName, storageName, filter) { 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("sharedStoragePublicService list", {
+                                methodName: methodName,
+                                storageName: storageName,
+                            });
+                        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.sharedStorageConnectionService.list(filter)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: "",
+                                storageName: storageName,
+                                agentName: "",
+                                swarmName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Clears all items from the storage.
+         * @returns {Promise<void>}
+         */
+        this.clear = function (methodName, storageName) { 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("sharedStoragePublicService clear", {
+                                methodName: methodName,
+                                storageName: storageName,
+                            });
+                        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.sharedStorageConnectionService.clear()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                methodName: methodName,
+                                clientId: "",
+                                storageName: storageName,
+                                agentName: "",
+                                swarmName: "",
+                                stateName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return SharedStoragePublicService;
+}());
+
+{
+    provide(TYPES.docService, function () { return new DocService(); });
+    provide(TYPES.busService, function () { return new BusService(); });
+    provide(TYPES.loggerService, function () { return new LoggerService(); });
+}
+{
+    provide(TYPES.methodContextService, function () { return new MethodContextService(); });
+    provide(TYPES.executionContextService, function () { return new ExecutionContextService(); });
+}
+{
+    provide(TYPES.agentConnectionService, function () { return new AgentConnectionService(); });
+    provide(TYPES.historyConnectionService, function () { return new HistoryConnectionService(); });
+    provide(TYPES.swarmConnectionService, function () { return new SwarmConnectionService(); });
+    provide(TYPES.sessionConnectionService, function () { return new SessionConnectionService(); });
+    provide(TYPES.storageConnectionService, function () { return new StorageConnectionService(); });
+    provide(TYPES.sharedStorageConnectionService, function () { return new SharedStorageConnectionService(); });
+    provide(TYPES.stateConnectionService, function () { return new StateConnectionService(); });
+    provide(TYPES.sharedStateConnectionService, function () { return new SharedStateConnectionService(); });
+}
+{
+    provide(TYPES.agentSchemaService, function () { return new AgentSchemaService(); });
+    provide(TYPES.toolSchemaService, function () { return new ToolSchemaService(); });
+    provide(TYPES.swarmSchemaService, function () { return new SwarmSchemaService(); });
+    provide(TYPES.completionSchemaService, function () { return new CompletionSchemaService(); });
+    provide(TYPES.embeddingSchemaService, function () { return new EmbeddingSchemaService(); });
+    provide(TYPES.storageSchemaService, function () { return new StorageSchemaService(); });
     provide(TYPES.stateSchemaService, function () { return new StateSchemaService(); });
 }
 {
@@ -8162,7 +8883,9 @@ var DocService = /** @class */ (function () {
     provide(TYPES.sessionPublicService, function () { return new SessionPublicService(); });
     provide(TYPES.swarmPublicService, function () { return new SwarmPublicService(); });
     provide(TYPES.storagePublicService, function () { return new StoragePublicService(); });
+    provide(TYPES.sharedStoragePublicService, function () { return new SharedStoragePublicService(); });
     provide(TYPES.statePublicService, function () { return new StatePublicService(); });
+    provide(TYPES.sharedStatePublicService, function () { return new SharedStatePublicService(); });
 }
 {
     provide(TYPES.swarmMetaService, function () { return new SwarmMetaService(); });
@@ -8199,7 +8922,9 @@ var connectionServices = {
     swarmConnectionService: inject(TYPES.swarmConnectionService),
     sessionConnectionService: inject(TYPES.sessionConnectionService),
     storageConnectionService: inject(TYPES.storageConnectionService),
+    sharedStorageConnectionService: inject(TYPES.sharedStorageConnectionService),
     stateConnectionService: inject(TYPES.stateConnectionService),
+    sharedStateConnectionService: inject(TYPES.sharedStateConnectionService),
 };
 var schemaServices = {
     agentSchemaService: inject(TYPES.agentSchemaService),
@@ -8216,7 +8941,9 @@ var publicServices = {
     sessionPublicService: inject(TYPES.sessionPublicService),
     swarmPublicService: inject(TYPES.swarmPublicService),
     storagePublicService: inject(TYPES.storagePublicService),
+    sharedStoragePublicService: inject(TYPES.sharedStoragePublicService),
     statePublicService: inject(TYPES.statePublicService),
+    sharedStatePublicService: inject(TYPES.sharedStatePublicService),
 };
 var metaServices = {
     agentMetaService: inject(TYPES.agentMetaService),
@@ -8235,7 +8962,7 @@ var swarm = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, b
 init();
 var swarm$1 = swarm;
 
-var METHOD_NAME$H = "cli.dumpDocs";
+var METHOD_NAME$J = "cli.dumpDocs";
 /**
  * Dumps the documentation for the agents and swarms.
  *
@@ -8246,7 +8973,7 @@ var METHOD_NAME$H = "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$H, {
+        swarm$1.loggerService.log(METHOD_NAME$J, {
             dirName: dirName,
         });
     if (PlantUML) {
@@ -8257,12 +8984,12 @@ var dumpDocs = function (dirName, PlantUML) {
     swarm$1.agentValidationService
         .getAgentList()
         .forEach(function (agentName) {
-        return swarm$1.agentValidationService.validate(agentName, METHOD_NAME$H);
+        return swarm$1.agentValidationService.validate(agentName, METHOD_NAME$J);
     });
     swarm$1.swarmValidationService
         .getSwarmList()
         .forEach(function (swarmName) {
-        return swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
+        return swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$J);
     });
     swarm$1.agentValidationService.getAgentList().forEach(function (agentName) {
         var dependsOn = swarm$1.agentSchemaService.get(agentName).dependsOn;
@@ -8273,7 +9000,7 @@ var dumpDocs = function (dirName, PlantUML) {
     return swarm$1.docService.dumpDocs(dirName);
 };
 
-var METHOD_NAME$G = "cli.dumpAgent";
+var METHOD_NAME$I = "cli.dumpAgent";
 /**
  * Dumps the agent information into PlantUML format.
  *
@@ -8283,14 +9010,14 @@ var METHOD_NAME$G = "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$G, {
+        swarm$1.loggerService.log(METHOD_NAME$I, {
             agentName: agentName,
         });
-    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$G);
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$I);
     return swarm$1.agentMetaService.toUML(agentName, withSubtree);
 };
 
-var METHOD_NAME$F = "cli.dumpSwarm";
+var METHOD_NAME$H = "cli.dumpSwarm";
 /**
  * Dumps the swarm information into PlantUML format.
  *
@@ -8299,14 +9026,14 @@ var METHOD_NAME$F = "cli.dumpSwarm";
  */
 var dumpSwarm = function (swarmName) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$F, {
+        swarm$1.loggerService.log(METHOD_NAME$H, {
             swarmName: swarmName,
         });
-    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$F);
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$H);
     return swarm$1.swarmMetaService.toUML(swarmName);
 };
 
-var METHOD_NAME$E = "function.addAgent";
+var METHOD_NAME$G = "function.addAgent";
 /**
  * Adds a new agent to the agent registry. The swarm takes only those agents which was registered
  *
@@ -8315,7 +9042,7 @@ var METHOD_NAME$E = "function.addAgent";
  */
 var addAgent = function (agentSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$E, {
+        swarm$1.loggerService.log(METHOD_NAME$G, {
             agentSchema: agentSchema,
         });
     swarm$1.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
@@ -8323,7 +9050,7 @@ var addAgent = function (agentSchema) {
     return agentSchema.agentName;
 };
 
-var METHOD_NAME$D = "function.addCompletion";
+var METHOD_NAME$F = "function.addCompletion";
 /**
  * Adds a completion engine for agents. Agents could use different models and
  * framewords for completion like: mock, gpt4all, ollama, openai
@@ -8333,7 +9060,7 @@ var METHOD_NAME$D = "function.addCompletion";
  */
 var addCompletion = function (completionSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$D, {
+        swarm$1.loggerService.log(METHOD_NAME$F, {
             completionSchema: completionSchema,
         });
     swarm$1.completionValidationService.addCompletion(completionSchema.completionName);
@@ -8341,7 +9068,7 @@ var addCompletion = function (completionSchema) {
     return completionSchema.completionName;
 };
 
-var METHOD_NAME$C = "function.addSwarm";
+var METHOD_NAME$E = "function.addSwarm";
 /**
  * Adds a new swarm to the system. The swarm is a root for starting client session
  *
@@ -8350,7 +9077,7 @@ var METHOD_NAME$C = "function.addSwarm";
  */
 var addSwarm = function (swarmSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$C, {
+        swarm$1.loggerService.log(METHOD_NAME$E, {
             swarmSchema: swarmSchema,
         });
     swarm$1.swarmValidationService.addSwarm(swarmSchema.swarmName, swarmSchema);
@@ -8358,7 +9085,7 @@ var addSwarm = function (swarmSchema) {
     return swarmSchema.swarmName;
 };
 
-var METHOD_NAME$B = "function.addTool";
+var METHOD_NAME$D = "function.addTool";
 /**
  * Adds a new tool for agents in a swarm. Tool should be registered in `addAgent`
  * declaration
@@ -8368,7 +9095,7 @@ var METHOD_NAME$B = "function.addTool";
  */
 var addTool = function (toolSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$B, {
+        swarm$1.loggerService.log(METHOD_NAME$D, {
             toolSchema: toolSchema,
         });
     swarm$1.toolValidationService.addTool(toolSchema.toolName, toolSchema);
@@ -8376,7 +9103,7 @@ var addTool = function (toolSchema) {
     return toolSchema.toolName;
 };
 
-var METHOD_NAME$A = "function.addState";
+var METHOD_NAME$C = "function.addState";
 /**
  * Adds a new state to the state registry. The swarm takes only those states which was registered
  *
@@ -8385,19 +9112,19 @@ var METHOD_NAME$A = "function.addState";
  */
 var addState = function (stateSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$A, {
+        swarm$1.loggerService.log(METHOD_NAME$C, {
             stateSchema: stateSchema,
         });
     swarm$1.stateSchemaService.register(stateSchema.stateName, stateSchema);
     if (stateSchema.shared) {
-        swarm$1.stateConnectionService
-            .getSharedStateRef("shared", stateSchema.stateName)
+        swarm$1.sharedStateConnectionService
+            .getStateRef(stateSchema.stateName)
             .waitForInit();
     }
     return stateSchema.stateName;
 };
 
-var METHOD_NAME$z = "function.addEmbedding";
+var METHOD_NAME$B = "function.addEmbedding";
 /**
  * Adds a new embedding to the embedding registry. The swarm takes only those embeddings which was registered
  *
@@ -8406,7 +9133,7 @@ var METHOD_NAME$z = "function.addEmbedding";
  */
 var addEmbedding = function (embeddingSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$z, {
+        swarm$1.loggerService.log(METHOD_NAME$B, {
             embeddingSchema: embeddingSchema,
         });
     swarm$1.embeddingValidationService.addEmbedding(embeddingSchema.embeddingName, embeddingSchema);
@@ -8414,7 +9141,7 @@ var addEmbedding = function (embeddingSchema) {
     return embeddingSchema.embeddingName;
 };
 
-var METHOD_NAME$y = "function.addStorage";
+var METHOD_NAME$A = "function.addStorage";
 /**
  * Adds a new storage to the storage registry. The swarm takes only those storages which was registered
  *
@@ -8423,20 +9150,20 @@ var METHOD_NAME$y = "function.addStorage";
  */
 var addStorage = function (storageSchema) {
     GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-        swarm$1.loggerService.log(METHOD_NAME$y, {
+        swarm$1.loggerService.log(METHOD_NAME$A, {
             storageSchema: storageSchema,
         });
     swarm$1.storageValidationService.addStorage(storageSchema.storageName, storageSchema);
     swarm$1.storageSchemaService.register(storageSchema.storageName, storageSchema);
     if (storageSchema.shared) {
-        swarm$1.storageConnectionService
-            .getSharedStorage("shared", storageSchema.storageName)
+        swarm$1.sharedStorageConnectionService
+            .getStorage(storageSchema.storageName)
             .waitForInit();
     }
     return storageSchema.storageName;
 };
 
-var METHOD_NAME$x = "function.commitToolOutput";
+var METHOD_NAME$z = "function.commitToolOutput";
 /**
  * Commits the tool output to the active agent in a swarm session
  *
@@ -8451,17 +9178,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$x, {
+                    swarm$1.loggerService.log(METHOD_NAME$z, {
                         toolId: toolId,
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$x);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$z);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$z);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$z);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$z, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -8474,7 +9201,7 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$x, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$z, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -8482,7 +9209,7 @@ var commitToolOutput = function (toolId, content, clientId, agentName) { return
     });
 }); };
 
-var METHOD_NAME$w = "function.commitSystemMessage";
+var METHOD_NAME$y = "function.commitSystemMessage";
 /**
  * Commits a system message to the active agent in the swarm.
  *
@@ -8497,16 +9224,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$w, {
+                    swarm$1.loggerService.log(METHOD_NAME$y, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$w);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$w);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$y);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$y);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$w);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$w, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$y);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$y, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -8518,7 +9245,7 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$w, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$y, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -8526,7 +9253,7 @@ var commitSystemMessage = function (content, clientId, agentName) { return __awa
     });
 }); };
 
-var METHOD_NAME$v = "function.commitFlush";
+var METHOD_NAME$x = "function.commitFlush";
 /**
  * Commits flush of agent history
  *
@@ -8540,15 +9267,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$v, {
+                    swarm$1.loggerService.log(METHOD_NAME$x, {
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$v);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$x);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$x);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$v, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$x);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$x, clientId, swarmName)];
             case 1:
                 currentAgentName = _a.sent();
                 if (currentAgentName !== agentName) {
@@ -8560,7 +9287,7 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$v, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$x, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -8568,7 +9295,7 @@ var commitFlush = function (clientId, agentName) { return __awaiter(void 0, void
     });
 }); };
 
-var METHOD_NAME$u = "function.commitSystemMessage";
+var METHOD_NAME$w = "function.commitSystemMessage";
 /**
  * Commits a user message to the active agent history in as swarm without answer.
  *
@@ -8583,16 +9310,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$u, {
+                    swarm$1.loggerService.log(METHOD_NAME$w, {
                         content: content,
                         clientId: clientId,
                         agentName: agentName,
                     });
-                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$u);
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
+                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$u);
-                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$u, 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) {
@@ -8604,7 +9331,7 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
                         });
                     return [2 /*return*/];
                 }
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$u, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$w, clientId, swarmName)];
             case 2:
                 _a.sent();
                 return [2 /*return*/];
@@ -8612,7 +9339,7 @@ var commitUserMessage = function (content, clientId, agentName) { return __await
     });
 }); };
 
-var METHOD_NAME$t = "function.commitToolOutputForce";
+var METHOD_NAME$v = "function.commitToolOutputForce";
 /**
  * Commits the tool output to the active agent in a swarm session without checking active agent
  *
@@ -8626,15 +9353,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$t, {
+                    swarm$1.loggerService.log(METHOD_NAME$v, {
                         toolId: toolId,
                         content: content,
                         clientId: clientId,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$v);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$t, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$v);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitToolOutput(toolId, content, METHOD_NAME$v, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -8642,7 +9369,7 @@ var commitToolOutputForce = function (toolId, content, clientId) { return __awai
     });
 }); };
 
-var METHOD_NAME$s = "function.commitSystemMessageForce";
+var METHOD_NAME$u = "function.commitSystemMessageForce";
 /**
  * Commits a system message to the active agent in as swarm without checking active agent.
  *
@@ -8656,14 +9383,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$s, {
+                    swarm$1.loggerService.log(METHOD_NAME$u, {
                         content: content,
                         clientId: clientId,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$u);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$s, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$u);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitSystemMessage(content, METHOD_NAME$u, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -8671,7 +9398,7 @@ var commitSystemMessageForce = function (content, clientId) { return __awaiter(v
     });
 }); };
 
-var METHOD_NAME$r = "function.commitFlushForce";
+var METHOD_NAME$t = "function.commitFlushForce";
 /**
  * Commits flush of agent history without active agent check
  *
@@ -8684,14 +9411,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$r, {
+                    swarm$1.loggerService.log(METHOD_NAME$t, {
                         clientId: clientId,
-                        METHOD_NAME: METHOD_NAME$r,
+                        METHOD_NAME: METHOD_NAME$t,
                     });
-                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$t);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$r);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$r, clientId, swarmName)];
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$t);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitFlush(METHOD_NAME$t, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -8699,7 +9426,7 @@ var commitFlushForce = function (clientId) { return __awaiter(void 0, void 0, vo
     });
 }); };
 
-var METHOD_NAME$q = "function.commitSystemMessage";
+var METHOD_NAME$s = "function.commitSystemMessage";
 /**
  * Commits a user message to the active agent history in as swarm without answer and checking active agent
  *
@@ -8708,6 +9435,79 @@ var METHOD_NAME$q = "function.commitSystemMessage";
  * @returns {Promise<void>} - A promise that resolves when the message is committed.
  */
 var commitUserMessageForce = function (content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
+    var swarmName;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                    swarm$1.loggerService.log(METHOD_NAME$s, {
+                        content: content,
+                        clientId: clientId,
+                    });
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$s);
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$s, clientId, swarmName)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+
+var METHOD_NAME$r = "function.commitAssistantMessage";
+/**
+ * Commits an assistant message to the active agent in the swarm.
+ *
+ * @param {string} content - The content of the assistant message.
+ * @param {string} clientId - The ID of the client.
+ * @param {string} agentName - The name of the agent.
+ * @returns {Promise<void>} - A promise that resolves when the message is committed.
+ */
+var commitAssistantMessage = function (content, clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
+    var swarmName, currentAgentName;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                    swarm$1.loggerService.log(METHOD_NAME$r, {
+                        content: content,
+                        clientId: clientId,
+                        agentName: agentName,
+                    });
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$r);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$r);
+                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)];
+            case 1:
+                currentAgentName = _a.sent();
+                if (currentAgentName !== agentName) {
+                    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                        swarm$1.loggerService.log('function "commitAssistantMessage" skipped due to the agent change', {
+                            currentAgentName: currentAgentName,
+                            agentName: agentName,
+                            clientId: clientId,
+                        });
+                    return [2 /*return*/];
+                }
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$r, clientId, swarmName)];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+
+var METHOD_NAME$q = "function.commitAssistantMessageForce";
+/**
+ * Commits an assistant message to the active agent in as swarm without checking active agent.
+ *
+ * @param {string} content - The content of the assistant message.
+ * @param {string} clientId - The ID of the client.
+ * @returns {Promise<void>} - A promise that resolves when the message is committed.
+ */
+var commitAssistantMessageForce = function (content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
     var swarmName;
     return __generator(this, function (_a) {
         switch (_a.label) {
@@ -8720,7 +9520,7 @@ var commitUserMessageForce = function (content, clientId) { return __awaiter(voi
                 swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$q);
                 swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
                 swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$q);
-                return [4 /*yield*/, swarm$1.sessionPublicService.commitUserMessage(content, METHOD_NAME$q, clientId, swarmName)];
+                return [4 /*yield*/, swarm$1.sessionPublicService.commitAssistantMessage(content, METHOD_NAME$q, clientId, swarmName)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -8892,6 +9692,7 @@ var disposeConnection = function (clientId_1, swarmName_1) {
                             clientId: clientId,
                             swarmName: swarmName,
                         });
+                    swarm$1.sessionValidationService.validate(clientId, methodName);
                     swarm$1.swarmValidationService.validate(swarmName, methodName);
                     return [4 /*yield*/, swarm$1.sessionPublicService.dispose(methodName, clientId, swarmName)];
                 case 1:
@@ -8960,6 +9761,7 @@ var disposeConnection = function (clientId_1, swarmName_1) {
                     _a.sent();
                     swarm$1.sessionValidationService.removeSession(clientId);
                     swarm$1.busService.dispose(clientId);
+                    swarm$1.sessionValidationService.dispose(clientId);
                     return [2 /*return*/];
             }
         });
@@ -10409,47 +11211,203 @@ var validateClientId$1 = function (clientId) {
     }
 };
 /**
- * Hook to subscribe to storage events for a specific client.
- *
- * @param {string} clientId - The ID of the client to subscribe to storage events for.
- * @param {function} fn - The callback function to handle the storage event.
+ * Hook to subscribe to storage events for a specific client.
+ *
+ * @param {string} clientId - The ID of the client to subscribe to storage events for.
+ * @param {function} fn - The callback function to handle the storage event.
+ */
+var listenStorageEventOnce = function (clientId, filterFn, fn) {
+    swarm$1.loggerService.log("middleware listenStorageEventOnce", {
+        clientId: clientId,
+    });
+    validateClientId$1(clientId);
+    return swarm$1.busService.once(clientId, "storage-bus", filterFn, fn);
+};
+
+var validateClientId = function (clientId) {
+    if (clientId === "*") {
+        return;
+    }
+    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
+        throw new Error("agent-swarm listenSwarmEventOnce session not found for clientId=".concat(clientId));
+    }
+};
+/**
+ * Hook to subscribe to swarm events for a specific client.
+ *
+ * @param {string} clientId - The ID of the client to subscribe to events for.
+ * @param {(event: IBusEvent) => void} fn - The callback function to handle the event.
+ */
+var listenSwarmEventOnce = function (clientId, filterFn, fn) {
+    swarm$1.loggerService.log("middleware listenSwarmEventOnce", {
+        clientId: clientId,
+    });
+    validateClientId(clientId);
+    return swarm$1.busService.once(clientId, "swarm-bus", filterFn, fn);
+};
+
+var METHOD_NAME_GET$3 = "StateUtils.getState";
+var METHOD_NAME_SET$1 = "StateUtils.setState";
+/**
+ * Utility class for managing state in the agent swarm.
+ * @implements {TState}
+ */
+var StateUtils = /** @class */ (function () {
+    function StateUtils() {
+        var _this = this;
+        /**
+         * Retrieves the state for a given client and state name.
+         * @template T
+         * @param {Object} payload - The payload containing client and state information.
+         * @param {string} payload.clientId - The client ID.
+         * @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 () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+                            swarm$1.loggerService.log(METHOD_NAME_GET$3, {
+                                clientId: payload.clientId,
+                                stateName: payload.stateName,
+                            });
+                        swarm$1.sessionValidationService.validate(payload.clientId, METHOD_NAME_GET$3);
+                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
+                            throw new Error("agent-swarm StateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (getState)"));
+                        }
+                        return [4 /*yield*/, swarm$1.statePublicService.getState(METHOD_NAME_GET$3, payload.clientId, payload.stateName)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * Sets the state for a given client and state name.
+         * @template T
+         * @param {T | ((prevState: 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 {string} payload.clientId - The client ID.
+         * @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.setState = function (dispatchFn, payload) { 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$1, {
+                                clientId: payload.clientId,
+                                stateName: payload.stateName,
+                            });
+                        swarm$1.sessionValidationService.validate(payload.clientId, METHOD_NAME_SET$1);
+                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
+                            throw new Error("agent-swarm StateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (setState)"));
+                        }
+                        if (!(typeof dispatchFn === "function")) return [3 /*break*/, 2];
+                        return [4 /*yield*/, swarm$1.statePublicService.setState(dispatchFn, METHOD_NAME_SET$1, payload.clientId, payload.stateName)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2: return [4 /*yield*/, swarm$1.statePublicService.setState(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, dispatchFn];
+                        }); }); }, METHOD_NAME_SET$1, payload.clientId, payload.stateName)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return StateUtils;
+}());
+/**
+ * Instance of StateUtils for managing state.
+ * @type {StateUtils}
  */
-var listenStorageEventOnce = function (clientId, filterFn, fn) {
-    swarm$1.loggerService.log("middleware listenStorageEventOnce", {
-        clientId: clientId,
-    });
-    validateClientId$1(clientId);
-    return swarm$1.busService.once(clientId, "storage-bus", filterFn, fn);
-};
+var State = new StateUtils();
 
-var validateClientId = function (clientId) {
-    if (clientId === "*") {
-        return;
-    }
-    if (!swarm$1.sessionValidationService.hasSession(clientId)) {
-        throw new Error("agent-swarm listenSwarmEventOnce session not found for clientId=".concat(clientId));
+var METHOD_NAME_GET$2 = "SharedStateUtils.getSharedState";
+var METHOD_NAME_SET = "SharedStateUtils.setSharedState";
+/**
+ * Utility class for managing state in the agent swarm.
+ * @implements {TSharedState}
+ */
+var SharedStateUtils = /** @class */ (function () {
+    function SharedStateUtils() {
+        var _this = this;
+        /**
+         * 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 () {
+            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,
+                            });
+                        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)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * 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.
+         * @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 () {
+            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,
+                            });
+                        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)];
+                    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)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
     }
-};
+    return SharedStateUtils;
+}());
 /**
- * Hook to subscribe to swarm events for a specific client.
- *
- * @param {string} clientId - The ID of the client to subscribe to events for.
- * @param {(event: IBusEvent) => void} fn - The callback function to handle the event.
+ * Instance of SharedStateUtils for managing state.
+ * @type {SharedStateUtils}
  */
-var listenSwarmEventOnce = function (clientId, filterFn, fn) {
-    swarm$1.loggerService.log("middleware listenSwarmEventOnce", {
-        clientId: clientId,
-    });
-    validateClientId(clientId);
-    return swarm$1.busService.once(clientId, "swarm-bus", filterFn, fn);
-};
+var SharedState = new SharedStateUtils();
 
-var METHOD_NAME_TAKE = "StorageUtils.take";
-var METHOD_NAME_UPSERT = "StorageUtils.upsert";
-var METHOD_NAME_REMOVE = "StorageUtils.remove";
+var METHOD_NAME_TAKE$1 = "StorageUtils.take";
+var METHOD_NAME_UPSERT$1 = "StorageUtils.upsert";
+var METHOD_NAME_REMOVE$1 = "StorageUtils.remove";
 var METHOD_NAME_GET$1 = "StorageUtils.get";
-var METHOD_NAME_LIST = "StorageUtils.list";
-var METHOD_NAME_CLEAR = "StorageUtils.clear";
+var METHOD_NAME_LIST$1 = "StorageUtils.list";
+var METHOD_NAME_CLEAR$1 = "StorageUtils.clear";
 var StorageUtils = /** @class */ (function () {
     function StorageUtils() {
         var _this = this;
@@ -10468,18 +11426,19 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm$1.loggerService.log(METHOD_NAME_TAKE, {
+                            swarm$1.loggerService.log(METHOD_NAME_TAKE$1, {
                                 search: payload.search,
                                 total: payload.total,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                                 score: payload.score,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_TAKE);
+                        swarm$1.sessionValidationService.validate(payload.clientId, METHOD_NAME_TAKE$1);
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_TAKE$1);
                         if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (take)"));
                         }
-                        return [4 /*yield*/, swarm$1.storagePublicService.take(payload.search, payload.total, METHOD_NAME_TAKE, payload.clientId, payload.storageName, payload.score)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.take(payload.search, payload.total, METHOD_NAME_TAKE$1, payload.clientId, payload.storageName, payload.score)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
@@ -10498,16 +11457,17 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm$1.loggerService.log(METHOD_NAME_UPSERT, {
+                            swarm$1.loggerService.log(METHOD_NAME_UPSERT$1, {
                                 item: payload.item,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_UPSERT);
+                        swarm$1.sessionValidationService.validate(payload.clientId, METHOD_NAME_UPSERT$1);
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_UPSERT$1);
                         if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (upsert)"));
                         }
-                        return [4 /*yield*/, swarm$1.storagePublicService.upsert(payload.item, METHOD_NAME_UPSERT, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.upsert(payload.item, METHOD_NAME_UPSERT$1, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -10525,16 +11485,17 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm$1.loggerService.log(METHOD_NAME_REMOVE, {
+                            swarm$1.loggerService.log(METHOD_NAME_REMOVE$1, {
                                 itemId: payload.itemId,
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_REMOVE);
+                        swarm$1.sessionValidationService.validate(payload.clientId, METHOD_NAME_REMOVE$1);
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_REMOVE$1);
                         if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (remove)"));
                         }
-                        return [4 /*yield*/, swarm$1.storagePublicService.remove(payload.itemId, METHOD_NAME_REMOVE, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.remove(payload.itemId, METHOD_NAME_REMOVE$1, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -10581,15 +11542,15 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm$1.loggerService.log(METHOD_NAME_LIST, {
+                            swarm$1.loggerService.log(METHOD_NAME_LIST$1, {
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_LIST);
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_LIST$1);
                         if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (list)"));
                         }
-                        return [4 /*yield*/, swarm$1.storagePublicService.list(METHOD_NAME_LIST, payload.clientId, payload.storageName, payload.filter)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.list(METHOD_NAME_LIST$1, payload.clientId, payload.storageName, payload.filter)];
                     case 1: return [2 /*return*/, (_a.sent())];
                 }
             });
@@ -10606,15 +11567,15 @@ var StorageUtils = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
-                            swarm$1.loggerService.log(METHOD_NAME_CLEAR, {
+                            swarm$1.loggerService.log(METHOD_NAME_CLEAR$1, {
                                 clientId: payload.clientId,
                                 storageName: payload.storageName,
                             });
-                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_CLEAR);
+                        swarm$1.storageValidationService.validate(payload.storageName, METHOD_NAME_CLEAR$1);
                         if (!swarm$1.agentValidationService.hasStorage(payload.agentName, payload.storageName)) {
                             throw new Error("agent-swarm StorageUtils ".concat(payload.storageName, " not registered in ").concat(payload.agentName, " (clear)"));
                         }
-                        return [4 /*yield*/, swarm$1.storagePublicService.clear(METHOD_NAME_CLEAR, payload.clientId, payload.storageName)];
+                        return [4 /*yield*/, swarm$1.storagePublicService.clear(METHOD_NAME_CLEAR$1, payload.clientId, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -10624,84 +11585,173 @@ var StorageUtils = /** @class */ (function () {
 }());
 var Storage = new StorageUtils();
 
-var METHOD_NAME_GET = "StateUtils.getState";
-var METHOD_NAME_SET = "StateUtils.setState";
-/**
- * Utility class for managing state in the agent swarm.
- * @implements {TState}
- */
-var StateUtils = /** @class */ (function () {
-    function StateUtils() {
+var METHOD_NAME_TAKE = "SharedStorageUtils.take";
+var METHOD_NAME_UPSERT = "SharedStorageUtils.upsert";
+var METHOD_NAME_REMOVE = "SharedStorageUtils.remove";
+var METHOD_NAME_GET = "SharedStorageUtils.get";
+var METHOD_NAME_LIST = "SharedStorageUtils.list";
+var METHOD_NAME_CLEAR = "SharedStorageUtils.clear";
+var SharedStorageUtils = /** @class */ (function () {
+    function SharedStorageUtils() {
         var _this = this;
         /**
-         * Retrieves the state for a given client and state name.
+         * 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
-         * @param {Object} payload - The payload containing client and state information.
-         * @param {string} payload.clientId - The client ID.
-         * @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.take = function (payload) { 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, {
-                                clientId: payload.clientId,
-                                stateName: payload.stateName,
+                            swarm$1.loggerService.log(METHOD_NAME_TAKE, {
+                                search: payload.search,
+                                total: payload.total,
+                                storageName: payload.storageName,
+                                score: payload.score,
                             });
-                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
-                            throw new Error("agent-swarm StateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (getState)"));
+                        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())];
+                }
+            });
+        }); };
+        /**
+         * 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 () {
+            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,
+                            });
+                        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.statePublicService.getState(METHOD_NAME_GET, payload.clientId, payload.stateName)];
+                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.upsert(payload.item, METHOD_NAME_UPSERT, payload.storageName)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         }); };
         /**
-         * Sets the state for a given client and state name.
+         * 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 () {
+            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,
+                            });
+                        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)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        /**
+         * 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
-         * @param {T | ((prevState: 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 {string} payload.clientId - The client ID.
-         * @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.setState = function (dispatchFn, payload) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
+        this.get = function (payload) { 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, {
-                                clientId: payload.clientId,
-                                stateName: payload.stateName,
+                            swarm$1.loggerService.log(METHOD_NAME_GET, {
+                                itemId: payload.itemId,
+                                storageName: payload.storageName,
                             });
-                        if (!swarm$1.agentValidationService.hasState(payload.agentName, payload.stateName)) {
-                            throw new Error("agent-swarm StateUtils ".concat(payload.stateName, " not registered in ").concat(payload.agentName, " (setState)"));
+                        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)"));
                         }
-                        if (!(typeof dispatchFn === "function")) return [3 /*break*/, 2];
-                        return [4 /*yield*/, swarm$1.statePublicService.setState(dispatchFn, METHOD_NAME_SET, payload.clientId, payload.stateName)];
+                        return [4 /*yield*/, swarm$1.sharedStoragePublicService.get(payload.itemId, METHOD_NAME_GET, payload.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 () {
+            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,
+                            });
+                        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)];
+                    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 () {
+            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,
+                            });
+                        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)];
                     case 1: return [2 /*return*/, _a.sent()];
-                    case 2: return [4 /*yield*/, swarm$1.statePublicService.setState(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, dispatchFn];
-                        }); }); }, METHOD_NAME_SET, payload.clientId, payload.stateName)];
-                    case 3: return [2 /*return*/, _a.sent()];
                 }
             });
         }); };
     }
-    return StateUtils;
+    return SharedStorageUtils;
 }());
-/**
- * Instance of StateUtils for managing state.
- * @type {StateUtils}
- */
-var State = new StateUtils();
+var SharedStorage = new SharedStorageUtils();
 
 /**
  * Function that recursively flattens a nested object to array of entries.
@@ -10799,6 +11849,8 @@ exports.LoggerAdapter = LoggerAdapter;
 exports.LoggerInstance = LoggerInstance;
 exports.MethodContextService = MethodContextService;
 exports.Schema = Schema;
+exports.SharedState = SharedState;
+exports.SharedStorage = SharedStorage;
 exports.State = State;
 exports.Storage = Storage;
 exports.addAgent = addAgent;
@@ -10813,6 +11865,8 @@ exports.cancelOutputForce = cancelOutputForce;
 exports.changeToAgent = changeToAgent;
 exports.changeToDefaultAgent = changeToDefaultAgent;
 exports.changeToPrevAgent = changeToPrevAgent;
+exports.commitAssistantMessage = commitAssistantMessage;
+exports.commitAssistantMessageForce = commitAssistantMessageForce;
 exports.commitFlush = commitFlush;
 exports.commitFlushForce = commitFlushForce;
 exports.commitSystemMessage = commitSystemMessage;