agent-swarm-kit 1.0.83 → 1.0.85

package/build/index.cjs

@@ -195,6 +195,10 @@ var schemaServices$1 = {
     storageSchemaService: Symbol('storageSchemaService'),
     stateSchemaService: Symbol('stateSchemaService'),
 };
+var metaServices$1 = {
+    agentMetaService: Symbol('agentMetaService'),
+    swarmMetaService: Symbol('swarmMetaService'),
+};
 var publicServices$1 = {
     agentPublicService: Symbol('agentPublicService'),
     historyPublicService: Symbol('historyPublicService'),
@@ -212,7 +216,7 @@ var validationServices$1 = {
     embeddingValidationService: Symbol('embeddingValidationService'),
     storageValidationService: Symbol('storageValidationService'),
 };
-var TYPES = __assign(__assign(__assign(__assign(__assign(__assign({}, baseServices$1), contextServices$1), schemaServices$1), connectionServices$1), publicServices$1), validationServices$1);
+var TYPES = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, baseServices$1), contextServices$1), schemaServices$1), connectionServices$1), publicServices$1), validationServices$1), metaServices$1);
 
 /**
  * Service providing execution context information.
@@ -396,89 +400,161 @@ var HistoryInstance = /** @class */ (function () {
         if (callbacks.filterCondition) {
             this.iterate = function (agentName) {
                 return __asyncGenerator(this, arguments, function () {
-                    var _b, _c, item, e_1_1, _d, _e, item, e_2_1;
-                    var e_1, _f, e_2, _g;
-                    return __generator(this, function (_h) {
-                        switch (_h.label) {
+                    var _b, _c, item, e_1_1, _d, _e, content, e_2_1, _f, _g, item, e_3_1, _h, _j, content, e_4_1;
+                    var e_1, _k, e_2, _l, e_3, _m, e_4, _o;
+                    return __generator(this, function (_p) {
+                        switch (_p.label) {
                             case 0:
                                 GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                                     swarm$1.loggerService.debug(INSTANCE_METHOD_NAME_ITERATE_CONDITION, {
                                         clientId: this.clientId,
                                         agentName: agentName,
                                     });
-                                if (!this.callbacks.onRead) return [3 /*break*/, 12];
+                                if (!this.callbacks.onRead) return [3 /*break*/, 22];
                                 this.callbacks.onReadBegin &&
                                     this.callbacks.onReadBegin(this.clientId, agentName);
-                                _h.label = 1;
+                                _p.label = 1;
                             case 1:
-                                _h.trys.push([1, 8, 9, 10]);
+                                _p.trys.push([1, 8, 9, 10]);
                                 _b = __values(this._array), _c = _b.next();
-                                _h.label = 2;
+                                _p.label = 2;
                             case 2:
                                 if (!!_c.done) return [3 /*break*/, 7];
                                 item = _c.value;
                                 return [4 /*yield*/, __await(this.callbacks.filterCondition(item, this.clientId, agentName))];
                             case 3:
-                                if (!_h.sent()) return [3 /*break*/, 6];
+                                if (!_p.sent()) return [3 /*break*/, 6];
                                 this.callbacks.onRead(item, this.clientId, agentName);
                                 return [4 /*yield*/, __await(item)];
-                            case 4: return [4 /*yield*/, _h.sent()];
+                            case 4: return [4 /*yield*/, _p.sent()];
                             case 5:
-                                _h.sent();
-                                _h.label = 6;
+                                _p.sent();
+                                _p.label = 6;
                             case 6:
                                 _c = _b.next();
                                 return [3 /*break*/, 2];
                             case 7: return [3 /*break*/, 10];
                             case 8:
-                                e_1_1 = _h.sent();
+                                e_1_1 = _p.sent();
                                 e_1 = { error: e_1_1 };
                                 return [3 /*break*/, 10];
                             case 9:
                                 try {
-                                    if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
+                                    if (_c && !_c.done && (_k = _b.return)) _k.call(_b);
                                 }
                                 finally { if (e_1) throw e_1.error; }
                                 return [7 /*endfinally*/];
                             case 10:
-                                this.callbacks.onReadEnd &&
-                                    this.callbacks.onReadEnd(this.clientId, agentName);
-                                return [4 /*yield*/, __await(void 0)];
-                            case 11: return [2 /*return*/, _h.sent()];
+                                if (!this.callbacks.getSystemPrompt) return [3 /*break*/, 20];
+                                _p.label = 11;
+                            case 11:
+                                _p.trys.push([11, 18, 19, 20]);
+                                return [4 /*yield*/, __await(this.callbacks.getSystemPrompt(this.clientId, agentName))];
                             case 12:
-                                this.callbacks.onReadBegin &&
-                                    this.callbacks.onReadBegin(this.clientId, agentName);
-                                _h.label = 13;
+                                _d = __values.apply(void 0, [_p.sent()]), _e = _d.next();
+                                _p.label = 13;
                             case 13:
-                                _h.trys.push([13, 20, 21, 22]);
-                                _d = __values(this._array), _e = _d.next();
-                                _h.label = 14;
-                            case 14:
-                                if (!!_e.done) return [3 /*break*/, 19];
-                                item = _e.value;
-                                return [4 /*yield*/, __await(this.callbacks.filterCondition(item, this.clientId, agentName))];
+                                if (!!_e.done) return [3 /*break*/, 17];
+                                content = _e.value;
+                                return [4 /*yield*/, __await({
+                                        role: "system",
+                                        content: content,
+                                        agentName: agentName,
+                                        mode: "tool"
+                                    })];
+                            case 14: return [4 /*yield*/, _p.sent()];
                             case 15:
-                                if (!_h.sent()) return [3 /*break*/, 18];
-                                return [4 /*yield*/, __await(item)];
-                            case 16: return [4 /*yield*/, _h.sent()];
-                            case 17:
-                                _h.sent();
-                                _h.label = 18;
-                            case 18:
+                                _p.sent();
+                                _p.label = 16;
+                            case 16:
                                 _e = _d.next();
-                                return [3 /*break*/, 14];
-                            case 19: return [3 /*break*/, 22];
-                            case 20:
-                                e_2_1 = _h.sent();
+                                return [3 /*break*/, 13];
+                            case 17: return [3 /*break*/, 20];
+                            case 18:
+                                e_2_1 = _p.sent();
                                 e_2 = { error: e_2_1 };
-                                return [3 /*break*/, 22];
-                            case 21:
+                                return [3 /*break*/, 20];
+                            case 19:
                                 try {
-                                    if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
+                                    if (_e && !_e.done && (_l = _d.return)) _l.call(_d);
                                 }
                                 finally { if (e_2) throw e_2.error; }
                                 return [7 /*endfinally*/];
+                            case 20:
+                                this.callbacks.onReadEnd &&
+                                    this.callbacks.onReadEnd(this.clientId, agentName);
+                                return [4 /*yield*/, __await(void 0)];
+                            case 21: return [2 /*return*/, _p.sent()];
                             case 22:
+                                this.callbacks.onReadBegin &&
+                                    this.callbacks.onReadBegin(this.clientId, agentName);
+                                _p.label = 23;
+                            case 23:
+                                _p.trys.push([23, 30, 31, 32]);
+                                _f = __values(this._array), _g = _f.next();
+                                _p.label = 24;
+                            case 24:
+                                if (!!_g.done) return [3 /*break*/, 29];
+                                item = _g.value;
+                                return [4 /*yield*/, __await(this.callbacks.filterCondition(item, this.clientId, agentName))];
+                            case 25:
+                                if (!_p.sent()) return [3 /*break*/, 28];
+                                return [4 /*yield*/, __await(item)];
+                            case 26: return [4 /*yield*/, _p.sent()];
+                            case 27:
+                                _p.sent();
+                                _p.label = 28;
+                            case 28:
+                                _g = _f.next();
+                                return [3 /*break*/, 24];
+                            case 29: return [3 /*break*/, 32];
+                            case 30:
+                                e_3_1 = _p.sent();
+                                e_3 = { error: e_3_1 };
+                                return [3 /*break*/, 32];
+                            case 31:
+                                try {
+                                    if (_g && !_g.done && (_m = _f.return)) _m.call(_f);
+                                }
+                                finally { if (e_3) throw e_3.error; }
+                                return [7 /*endfinally*/];
+                            case 32:
+                                if (!this.callbacks.getSystemPrompt) return [3 /*break*/, 42];
+                                _p.label = 33;
+                            case 33:
+                                _p.trys.push([33, 40, 41, 42]);
+                                return [4 /*yield*/, __await(this.callbacks.getSystemPrompt(this.clientId, agentName))];
+                            case 34:
+                                _h = __values.apply(void 0, [_p.sent()]), _j = _h.next();
+                                _p.label = 35;
+                            case 35:
+                                if (!!_j.done) return [3 /*break*/, 39];
+                                content = _j.value;
+                                return [4 /*yield*/, __await({
+                                        role: "system",
+                                        content: content,
+                                        agentName: agentName,
+                                        mode: "tool"
+                                    })];
+                            case 36: return [4 /*yield*/, _p.sent()];
+                            case 37:
+                                _p.sent();
+                                _p.label = 38;
+                            case 38:
+                                _j = _h.next();
+                                return [3 /*break*/, 35];
+                            case 39: return [3 /*break*/, 42];
+                            case 40:
+                                e_4_1 = _p.sent();
+                                e_4 = { error: e_4_1 };
+                                return [3 /*break*/, 42];
+                            case 41:
+                                try {
+                                    if (_j && !_j.done && (_o = _h.return)) _o.call(_h);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                                return [7 /*endfinally*/];
+                            case 42:
                                 this.callbacks.onReadEnd &&
                                     this.callbacks.onReadEnd(this.clientId, agentName);
                                 return [2 /*return*/];
@@ -509,10 +585,10 @@ var HistoryInstance = /** @class */ (function () {
      */
     HistoryInstance.prototype.iterate = function (agentName) {
         return __asyncGenerator(this, arguments, function iterate_1() {
-            var _b, _c, item, e_3_1, _d, _e, item, e_4_1;
-            var e_3, _f, e_4, _g;
-            return __generator(this, function (_h) {
-                switch (_h.label) {
+            var _b, _c, item, e_5_1, _d, _e, item, e_6_1, _f, _g, content, e_7_1;
+            var e_5, _h, e_6, _j, e_7, _k;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
                     case 0:
                         GLOBAL_CONFIG.CC_LOGGER_ENABLE_DEBUG &&
                             swarm$1.loggerService.debug(INSTANCE_METHOD_NAME_ITERATE, {
@@ -522,70 +598,106 @@ var HistoryInstance = /** @class */ (function () {
                         if (!this.callbacks.onRead) return [3 /*break*/, 11];
                         this.callbacks.onReadBegin &&
                             this.callbacks.onReadBegin(this.clientId, agentName);
-                        _h.label = 1;
+                        _l.label = 1;
                     case 1:
-                        _h.trys.push([1, 7, 8, 9]);
+                        _l.trys.push([1, 7, 8, 9]);
                         _b = __values(this._array), _c = _b.next();
-                        _h.label = 2;
+                        _l.label = 2;
                     case 2:
                         if (!!_c.done) return [3 /*break*/, 6];
                         item = _c.value;
                         this.callbacks.onRead(item, this.clientId, agentName);
                         return [4 /*yield*/, __await(item)];
-                    case 3: return [4 /*yield*/, _h.sent()];
+                    case 3: return [4 /*yield*/, _l.sent()];
                     case 4:
-                        _h.sent();
-                        _h.label = 5;
+                        _l.sent();
+                        _l.label = 5;
                     case 5:
                         _c = _b.next();
                         return [3 /*break*/, 2];
                     case 6: return [3 /*break*/, 9];
                     case 7:
-                        e_3_1 = _h.sent();
-                        e_3 = { error: e_3_1 };
+                        e_5_1 = _l.sent();
+                        e_5 = { error: e_5_1 };
                         return [3 /*break*/, 9];
                     case 8:
                         try {
-                            if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
+                            if (_c && !_c.done && (_h = _b.return)) _h.call(_b);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_5) throw e_5.error; }
                         return [7 /*endfinally*/];
                     case 9:
                         this.callbacks.onReadEnd &&
                             this.callbacks.onReadEnd(this.clientId, agentName);
                         return [4 /*yield*/, __await(void 0)];
-                    case 10: return [2 /*return*/, _h.sent()];
+                    case 10: return [2 /*return*/, _l.sent()];
                     case 11:
                         this.callbacks.onReadBegin &&
                             this.callbacks.onReadBegin(this.clientId, agentName);
-                        _h.label = 12;
+                        _l.label = 12;
                     case 12:
-                        _h.trys.push([12, 18, 19, 20]);
+                        _l.trys.push([12, 18, 19, 20]);
                         _d = __values(this._array), _e = _d.next();
-                        _h.label = 13;
+                        _l.label = 13;
                     case 13:
                         if (!!_e.done) return [3 /*break*/, 17];
                         item = _e.value;
                         return [4 /*yield*/, __await(item)];
-                    case 14: return [4 /*yield*/, _h.sent()];
+                    case 14: return [4 /*yield*/, _l.sent()];
                     case 15:
-                        _h.sent();
-                        _h.label = 16;
+                        _l.sent();
+                        _l.label = 16;
                     case 16:
                         _e = _d.next();
                         return [3 /*break*/, 13];
                     case 17: return [3 /*break*/, 20];
                     case 18:
-                        e_4_1 = _h.sent();
-                        e_4 = { error: e_4_1 };
+                        e_6_1 = _l.sent();
+                        e_6 = { error: e_6_1 };
                         return [3 /*break*/, 20];
                     case 19:
                         try {
-                            if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
+                            if (_e && !_e.done && (_j = _d.return)) _j.call(_d);
                         }
-                        finally { if (e_4) throw e_4.error; }
+                        finally { if (e_6) throw e_6.error; }
                         return [7 /*endfinally*/];
                     case 20:
+                        if (!this.callbacks.getSystemPrompt) return [3 /*break*/, 30];
+                        _l.label = 21;
+                    case 21:
+                        _l.trys.push([21, 28, 29, 30]);
+                        return [4 /*yield*/, __await(this.callbacks.getSystemPrompt(this.clientId, agentName))];
+                    case 22:
+                        _f = __values.apply(void 0, [_l.sent()]), _g = _f.next();
+                        _l.label = 23;
+                    case 23:
+                        if (!!_g.done) return [3 /*break*/, 27];
+                        content = _g.value;
+                        return [4 /*yield*/, __await({
+                                role: "system",
+                                content: content,
+                                agentName: agentName,
+                                mode: "tool"
+                            })];
+                    case 24: return [4 /*yield*/, _l.sent()];
+                    case 25:
+                        _l.sent();
+                        _l.label = 26;
+                    case 26:
+                        _g = _f.next();
+                        return [3 /*break*/, 23];
+                    case 27: return [3 /*break*/, 30];
+                    case 28:
+                        e_7_1 = _l.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 30];
+                    case 29:
+                        try {
+                            if (_g && !_g.done && (_k = _f.return)) _k.call(_f);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
+                    case 30:
                         this.callbacks.onReadEnd &&
                             this.callbacks.onReadEnd(this.clientId, agentName);
                         return [2 /*return*/];
@@ -738,8 +850,8 @@ var HistoryUtils = /** @class */ (function () {
      */
     HistoryUtils.prototype.iterate = function (clientId, agentName) {
         return __asyncGenerator(this, arguments, function iterate_2() {
-            var isInitial, history, _b, _c, _d, item, e_5_1;
-            var _e, e_5, _f, _g;
+            var isInitial, history, _b, _c, _d, item, e_8_1;
+            var _e, e_8, _f, _g;
             return __generator(this, function (_h) {
                 switch (_h.label) {
                     case 0:
@@ -776,8 +888,8 @@ var HistoryUtils = /** @class */ (function () {
                         return [3 /*break*/, 4];
                     case 9: return [3 /*break*/, 16];
                     case 10:
-                        e_5_1 = _h.sent();
-                        e_5 = { error: e_5_1 };
+                        e_8_1 = _h.sent();
+                        e_8 = { error: e_8_1 };
                         return [3 /*break*/, 16];
                     case 11:
                         _h.trys.push([11, , 14, 15]);
@@ -788,7 +900,7 @@ var HistoryUtils = /** @class */ (function () {
                         _h.label = 13;
                     case 13: return [3 /*break*/, 15];
                     case 14:
-                        if (e_5) throw e_5.error;
+                        if (e_8) throw e_8.error;
                         return [7 /*endfinally*/];
                     case 15: return [7 /*endfinally*/];
                     case 16: return [2 /*return*/];
@@ -4825,6 +4937,7 @@ var AgentValidationService = /** @class */ (function () {
         this.completionValidationService = inject(TYPES.completionValidationService);
         this.storageValidationService = inject(TYPES.storageValidationService);
         this._agentMap = new Map();
+        this._agentDepsMap = new Map();
         /**
          * Retrieves the storages used by the agent
          * @param {agentName} agentName - The name of the swarm.
@@ -4865,6 +4978,9 @@ var AgentValidationService = /** @class */ (function () {
                 throw new Error("agent-swarm agent ".concat(agentName, " already exist"));
             }
             _this._agentMap.set(agentName, agentSchema);
+            if (agentSchema.dependsOn) {
+                _this._agentDepsMap.set(agentName, agentSchema.dependsOn);
+            }
         };
         /**
          * Check if agent got registered storage
@@ -4884,6 +5000,23 @@ var AgentValidationService = /** @class */ (function () {
             var _a = _this._agentMap.get(agentName).storages, storages = _a === void 0 ? [] : _a;
             return storages.includes(storageName);
         });
+        /**
+         * Check if agent got registered dependency
+         */
+        this.hasDependency = functoolsKit.memoize(function (_a) {
+            var _b = __read(_a, 2), targetAgentName = _b[0], depAgentName = _b[1];
+            return "".concat(targetAgentName, "-").concat(depAgentName);
+        }, function (targetAgentName, depAgentName) {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                _this.loggerService.info("agentValidationService hasDependency", {
+                    targetAgentName: targetAgentName,
+                    depAgentName: depAgentName,
+                });
+            if (_this._agentDepsMap.has(targetAgentName)) {
+                return _this._agentDepsMap.get(targetAgentName).includes(depAgentName);
+            }
+            return true;
+        });
         /**
          * Check if agent got registered state
          */
@@ -7081,6 +7214,162 @@ var BusService = /** @class */ (function () {
     return BusService;
 }());
 
+var MAX_NESTING = 10;
+var UML_STEP = "\t";
+var UML_BULLET = "•";
+/**
+ * Creates a function to serialize meta nodes to UML format.
+ * @returns {Function} A function that takes an array of IMetaNode and returns a string in UML format.
+ */
+var createSerialize = function () { return function (nodes) {
+    var lines = [];
+    var process = function (nodes, level, seen) {
+        var e_1, _a;
+        var _b;
+        if (level === void 0) { level = 0; }
+        if (seen === void 0) { seen = new Set(); }
+        try {
+            for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+                var node = nodes_1_1.value;
+                var space = __spreadArray([], __read(new Array(level)), false).fill(UML_STEP).join("");
+                if (seen.has(node.name)) {
+                    lines.push("".concat(space).concat(String(node.name), ": \"\""));
+                }
+                else if (((_b = node.child) === null || _b === void 0 ? void 0 : _b.length) && level < MAX_NESTING) {
+                    lines.push("".concat(space).concat(String(node.name), ":"));
+                    lines.push("".concat(space).concat(UML_STEP).concat(UML_BULLET, " ").concat(String(node.name), ": \"\""));
+                    process(node.child, level + 1, seen.add(node.name));
+                }
+                else {
+                    lines.push("".concat(space).concat(String(node.name), ": \"\""));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    process(nodes);
+    var result = __spreadArray(__spreadArray(["@startyaml"], __read(lines), false), ["@endyaml"], false).join("\n");
+    return result;
+}; };
+/**
+ * Service class for managing agent meta nodes and converting them to UML format.
+ */
+var AgentMetaService = /** @class */ (function () {
+    function AgentMetaService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.agentSchemaService = inject(TYPES.agentSchemaService);
+        this.serialize = createSerialize();
+        /**
+         * Creates a meta node for the given agent.
+         * @param {AgentName} agentName - The name of the agent.
+         * @param {Set<AgentName>} seen - A set of seen agent names to avoid circular dependencies.
+         * @returns {IMetaNode} The created meta node.
+         */
+        this.makeAgentNode = function (agentName, seen) {
+            if (seen === void 0) { seen = new Set(); }
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                _this.loggerService.info("agentMetaService makeAgentNode", {
+                    agentName: agentName,
+                });
+            var _a = _this.agentSchemaService.get(agentName), dependsOn = _a.dependsOn, states = _a.states, storages = _a.storages, tools = _a.tools;
+            var childSeen = seen.add(agentName);
+            var agentTree = [];
+            if (dependsOn && !seen.has(agentName)) {
+                agentTree.push({
+                    name: "Agents (".concat(agentName, ")"),
+                    child: dependsOn.map(function (dep) { return _this.makeAgentNode(dep, childSeen); }),
+                });
+            }
+            if (states) {
+                agentTree.push({
+                    name: "States (".concat(agentName, ")"),
+                    child: states.map(function (name) { return ({ name: name }); }),
+                });
+            }
+            if (storages) {
+                agentTree.push({
+                    name: "Storages (".concat(agentName, ")"),
+                    child: storages.map(function (name) { return ({ name: name }); }),
+                });
+            }
+            if (tools) {
+                agentTree.push({
+                    name: "Tools (".concat(agentName, ")"),
+                    child: tools.map(function (name) { return ({ name: name }); }),
+                });
+            }
+            return {
+                name: agentName,
+                child: agentTree,
+            };
+        };
+        /**
+         * Converts the meta nodes of the given agent to UML format.
+         * @param {AgentName} agentName - The name of the agent.
+         * @returns {string} The UML representation of the agent's meta nodes.
+         */
+        this.toUML = function (agentName) {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                _this.loggerService.info("agentMetaService toUML", {
+                    agentName: agentName,
+                });
+            var rootNode = _this.makeAgentNode(agentName);
+            return _this.serialize([rootNode]);
+        };
+    }
+    return AgentMetaService;
+}());
+
+/**
+ * Service for handling swarm metadata.
+ */
+var SwarmMetaService = /** @class */ (function () {
+    function SwarmMetaService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.swarmSchemaService = inject(TYPES.swarmSchemaService);
+        this.agentMetaService = inject(TYPES.agentMetaService);
+        this.serialize = createSerialize();
+        /**
+         * Creates a swarm node with the given swarm name.
+         * @param {SwarmName} swarmName - The name of the swarm.
+         * @returns {IMetaNode} The metadata node of the swarm.
+         */
+        this.makeSwarmNode = function (swarmName) {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                _this.loggerService.info("swarmMetaService makeSwarmNode", {
+                    swarmName: swarmName,
+                });
+            var agentList = _this.swarmSchemaService.get(swarmName).agentList;
+            return {
+                name: swarmName,
+                child: agentList.map(function (dep) { return _this.agentMetaService.makeAgentNode(dep); }),
+            };
+        };
+        /**
+         * Converts the swarm metadata to UML format.
+         * @param {SwarmName} swarmName - The name of the swarm.
+         * @returns {string} The UML representation of the swarm.
+         */
+        this.toUML = function (swarmName) {
+            GLOBAL_CONFIG.CC_LOGGER_ENABLE_INFO &&
+                _this.loggerService.info("swarmMetaService toUML", {
+                    swarmName: swarmName,
+                });
+            var rootNode = _this.makeSwarmNode(swarmName);
+            return _this.serialize([rootNode]);
+        };
+    }
+    return SwarmMetaService;
+}());
+
 {
     provide(TYPES.busService, function () { return new BusService(); });
     provide(TYPES.loggerService, function () { return new LoggerService(); });
@@ -7114,6 +7403,10 @@ var BusService = /** @class */ (function () {
     provide(TYPES.storagePublicService, function () { return new StoragePublicService(); });
     provide(TYPES.statePublicService, function () { return new StatePublicService(); });
 }
+{
+    provide(TYPES.swarmMetaService, function () { return new SwarmMetaService(); });
+    provide(TYPES.agentMetaService, function () { return new AgentMetaService(); });
+}
 {
     provide(TYPES.agentPublicService, function () { return new AgentPublicService(); });
     provide(TYPES.historyPublicService, function () { return new HistoryPublicService(); });
@@ -7163,6 +7456,10 @@ var publicServices = {
     storagePublicService: inject(TYPES.storagePublicService),
     statePublicService: inject(TYPES.statePublicService),
 };
+var metaServices = {
+    agentMetaService: inject(TYPES.agentMetaService),
+    swarmMetaService: inject(TYPES.swarmMetaService),
+};
 var validationServices = {
     agentValidationService: inject(TYPES.agentValidationService),
     toolValidationService: inject(TYPES.toolValidationService),
@@ -7172,10 +7469,42 @@ var validationServices = {
     storageValidationService: inject(TYPES.storageValidationService),
     embeddingValidationService: inject(TYPES.embeddingValidationService),
 };
-var swarm = __assign(__assign(__assign(__assign(__assign(__assign({}, baseServices), contextServices), connectionServices), schemaServices), publicServices), validationServices);
+var swarm = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, baseServices), contextServices), connectionServices), schemaServices), publicServices), metaServices), validationServices);
 init();
 var swarm$1 = swarm;
 
+var METHOD_NAME$E = "function.dumpAgent";
+/**
+ * Dumps the agent information into PlantUML format.
+ *
+ * @param {SwarmName} swarmName - The name of the swarm to be dumped.
+ * @returns {string} The UML representation of the swarm.
+ */
+var dumpAgent = function (agentName) {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$E, {
+            agentName: agentName,
+        });
+    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$E);
+    return swarm$1.agentMetaService.toUML(agentName);
+};
+
+var METHOD_NAME$D = "function.dumpSwarm";
+/**
+ * Dumps the swarm information into PlantUML format.
+ *
+ * @param {SwarmName} swarmName - The name of the swarm to be dumped.
+ * @returns {string} The UML representation of the swarm.
+ */
+var dumpSwarm = function (swarmName) {
+    GLOBAL_CONFIG.CC_LOGGER_ENABLE_LOG &&
+        swarm$1.loggerService.log(METHOD_NAME$D, {
+            swarmName: swarmName,
+        });
+    swarm$1.swarmValidationService.validate(swarmName, METHOD_NAME$D);
+    return swarm$1.swarmMetaService.toUML(swarmName);
+};
+
 var METHOD_NAME$C = "function.addAgent";
 /**
  * Adds a new agent to the agent registry. The swarm takes only those agents which was registered
@@ -7510,26 +7839,22 @@ var CHANGE_AGENT_GC = 60 * 1000;
  * @returns {TChangeAgentRun} - The change agent function.
  */
 var createChangeAgent = functoolsKit.ttl(function (clientId) {
-    return functoolsKit.queued(function (methodName, agentName) { return __awaiter(void 0, void 0, void 0, function () {
-        var swarmName, _a, _b, _c;
+    return functoolsKit.queued(function (methodName, agentName, swarmName) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
-                case 0:
-                    swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
-                    swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
-                    swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
-                    return [4 /*yield*/, Promise.all(swarm$1.swarmValidationService
-                            .getAgentList(swarmName)
-                            .map(function (agentName) { return __awaiter(void 0, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName)];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
+                case 0: return [4 /*yield*/, Promise.all(swarm$1.swarmValidationService
+                        .getAgentList(swarmName)
+                        .map(function (agentName) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, swarm$1.agentPublicService.commitAgentChange(methodName, clientId, agentName)];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); }))];
                 case 1:
                     _d.sent();
                     return [4 /*yield*/, swarm$1.agentPublicService.dispose(methodName, clientId, agentName)];
@@ -7581,7 +7906,7 @@ var createGc$1 = functoolsKit.singleshot(function () { return __awaiter(void 0,
  * @returns {Promise<void>} - A promise that resolves when the agent is changed.
  */
 var changeAgent = function (agentName, clientId) { return __awaiter(void 0, void 0, void 0, function () {
-    var run;
+    var swarmName, activeAgent, run;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
@@ -7590,12 +7915,21 @@ var changeAgent = function (agentName, clientId) { return __awaiter(void 0, void
                         agentName: agentName,
                         clientId: clientId,
                     });
-                return [4 /*yield*/, createChangeAgent(clientId)];
+                swarmName = swarm$1.sessionValidationService.getSwarm(clientId);
+                swarm$1.sessionValidationService.validate(clientId, METHOD_NAME$s);
+                swarm$1.agentValidationService.validate(agentName, METHOD_NAME$s);
+                return [4 /*yield*/, swarm$1.swarmPublicService.getAgentName(METHOD_NAME$s, clientId, swarmName)];
             case 1:
+                activeAgent = _a.sent();
+                if (!swarm$1.agentValidationService.hasDependency(activeAgent, agentName)) {
+                    console.error("agent-swarm missing dependency detected for activeAgent=".concat(activeAgent, " dependencyAgent=").concat(agentName));
+                }
+                return [4 /*yield*/, createChangeAgent(clientId)];
+            case 2:
                 run = _a.sent();
                 createGc$1();
-                return [4 /*yield*/, run(METHOD_NAME$s, agentName)];
-            case 2: return [2 /*return*/, _a.sent()];
+                return [4 /*yield*/, run(METHOD_NAME$s, agentName, swarmName)];
+            case 3: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
@@ -9459,6 +9793,8 @@ exports.commitUserMessage = commitUserMessage;
 exports.commitUserMessageForce = commitUserMessageForce;
 exports.complete = complete;
 exports.disposeConnection = disposeConnection;
+exports.dumpAgent = dumpAgent;
+exports.dumpSwarm = dumpSwarm;
 exports.emit = emit;
 exports.emitForce = emitForce;
 exports.event = event;