agent-swarm-kit 0.0.1 → 1.0.0

package/build/index.mjs

@@ -0,0 +1,2323 @@
+import { scoped } from 'di-scoped';
+import { ToolRegistry, Subject, queued, not, trycatch, memoize, PubsubArrayAdapter, ttl, singleshot } from 'functools-kit';
+import { createActivator } from 'di-kit';
+import { omit } from 'lodash-es';
+import xml2js from 'xml2js';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var ContextService = scoped(/** @class */ (function () {
+    function class_1(context) {
+        this.context = context;
+    }
+    return class_1;
+}()));
+
+var LoggerService = /** @class */ (function () {
+    function LoggerService() {
+        var _this = this;
+        this._logger = {
+            log: function () {
+            },
+            debug: function () {
+            },
+        };
+        this.log = function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            (_a = _this._logger).log.apply(_a, __spreadArray([], __read(args), false));
+        };
+        this.debug = function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            (_a = _this._logger).debug.apply(_a, __spreadArray([], __read(args), false));
+        };
+        this.setLogger = function (logger) {
+            _this._logger = logger;
+        };
+    }
+    return LoggerService;
+}());
+
+var _a;
+var init = (_a = createActivator("agent-swarm"), _a.init), inject = _a.inject, provide = _a.provide;
+
+var baseServices$1 = {
+    loggerService: Symbol('loggerService'),
+    contextService: Symbol('contextService'),
+};
+var connectionServices$1 = {
+    agentConnectionService: Symbol('agentConnectionService'),
+    historyConnectionService: Symbol('historyConnectionService'),
+    swarmConnectionService: Symbol('swarmConnectionService'),
+    sessionConnectionService: Symbol('sessionConnectionService'),
+};
+var specServices$1 = {
+    completionSchemaService: Symbol('completionSchemaService'),
+    agentSchemaService: Symbol('agentSchemaService'),
+    swarmSchemaService: Symbol('swarmSchemaService'),
+    toolSchemaService: Symbol('toolSchemaService'),
+};
+var publicServices$1 = {
+    agentPublicService: Symbol('agentPublicService'),
+    historyPublicService: Symbol('historyPublicService'),
+    sessionPublicService: Symbol('sessionPublicService'),
+    swarmPublicService: Symbol('swarmPublicService'),
+};
+var validationServices$1 = {
+    agentValidationService: Symbol('agentValidationService'),
+    toolValidationService: Symbol('toolValidationService'),
+    sessionValidationService: Symbol('sessionValidationService'),
+    swarmValidationService: Symbol('swarmValidationService'),
+    completionValidationService: Symbol('completionValidationService'),
+};
+var TYPES = __assign(__assign(__assign(__assign(__assign({}, baseServices$1), specServices$1), connectionServices$1), publicServices$1), validationServices$1);
+
+var AgentSchemaService = /** @class */ (function () {
+    function AgentSchemaService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.registry = new ToolRegistry("agentSchemaService");
+        this.register = function (key, value) {
+            _this.loggerService.log("agentSchemaService register", { key: key });
+            _this.registry = _this.registry.register(key, value);
+        };
+        this.get = function (key) {
+            _this.loggerService.log("agentSchemaService get", { key: key });
+            return _this.registry.get(key);
+        };
+    }
+    return AgentSchemaService;
+}());
+
+/**
+ * @description `ask for agent function` in `llama3.1:8b` to troubleshoot (need CC_OLLAMA_EMIT_TOOL_PROTOCOL to be turned off)
+ */
+var CC_TOOL_CALL_EXCEPTION_PROMPT = "Start the conversation";
+/**
+ * @description When the model output is empty just say hello to the customer
+ */
+var CC_EMPTY_OUTPUT_PLACEHOLDERS = [
+    "Sorry, I missed that. Could you say it again?",
+    "I couldn't catch that. Would you mind repeating?",
+    "I didn’t quite hear you. Can you repeat that, please?",
+    "Pardon me, I didn’t hear that clearly. Could you repeat it?",
+    "Sorry, I didn’t catch what you said. Could you say it again?",
+    "Could you repeat that? I didn’t hear it clearly.",
+    "I missed that. Can you say it one more time?",
+    "Sorry, I didn’t get that. Could you repeat it, please?",
+    "I didn’t hear you properly. Can you say that again?",
+    "Could you please repeat that? I didn’t catch it.",
+];
+var CC_KEEP_MESSAGES = 5;
+var CC_ANSWER_TIMEOUT_SECONDS = 120000;
+var GLOBAL_CONFIG = {
+    CC_TOOL_CALL_EXCEPTION_PROMPT: CC_TOOL_CALL_EXCEPTION_PROMPT,
+    CC_EMPTY_OUTPUT_PLACEHOLDERS: CC_EMPTY_OUTPUT_PLACEHOLDERS,
+    CC_KEEP_MESSAGES: CC_KEEP_MESSAGES,
+    CC_ANSWER_TIMEOUT_SECONDS: CC_ANSWER_TIMEOUT_SECONDS,
+};
+var setConfig = function (config) {
+    Object.assign(GLOBAL_CONFIG, config);
+};
+
+var getPlaceholder = function () {
+    return GLOBAL_CONFIG.CC_EMPTY_OUTPUT_PLACEHOLDERS[Math.floor(Math.random() * GLOBAL_CONFIG.CC_EMPTY_OUTPUT_PLACEHOLDERS.length)];
+};
+var ClientAgent = /** @class */ (function () {
+    function ClientAgent(params) {
+        var _this = this;
+        this.params = params;
+        this._toolCommitSubject = new Subject();
+        this._outputSubject = new Subject();
+        this._emitOuput = function (result) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, result_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " _emitOuput"));
+                        validation = null;
+                        return [4 /*yield*/, this.params.validate(result)];
+                    case 1:
+                        if (!(validation = _a.sent())) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this._resurrectModel(validation)];
+                    case 2:
+                        result_1 = _a.sent();
+                        return [4 /*yield*/, this.params.validate(result_1)];
+                    case 3:
+                        if (validation = _a.sent()) {
+                            throw new Error("agent-swarm-kit ClientAgent agentName=".concat(this.params.agentName, " model ressurect failed: ").concat(validation));
+                        }
+                        return [4 /*yield*/, this._outputSubject.next(result_1)];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 5: return [4 /*yield*/, this._outputSubject.next(result)];
+                    case 6:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this._resurrectModel = function (reason) { return __awaiter(_this, void 0, void 0, function () {
+            var message, result, validation, content;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " _resurrectModel"));
+                        return [4 /*yield*/, this.params.history.push({
+                                role: "resque",
+                                agentName: this.params.agentName,
+                                content: reason || "Unknown error",
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.params.history.push({
+                                role: "user",
+                                agentName: this.params.agentName,
+                                content: GLOBAL_CONFIG.CC_TOOL_CALL_EXCEPTION_PROMPT,
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.getCompletion()];
+                    case 3:
+                        message = _a.sent();
+                        result = message.content;
+                        validation = null;
+                        return [4 /*yield*/, this.params.validate(result)];
+                    case 4:
+                        if (!(validation = _a.sent())) return [3 /*break*/, 6];
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " _resurrectModel validation error: ").concat(validation));
+                        content = getPlaceholder();
+                        return [4 /*yield*/, this.params.history.push({
+                                agentName: this.params.agentName,
+                                role: "assistant",
+                                content: content,
+                            })];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/, content];
+                    case 6: return [4 /*yield*/, this.params.history.push(__assign(__assign({}, message), { agentName: this.params.agentName }))];
+                    case 7:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        }); };
+        this.waitForOutput = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " waitForOutput"));
+                        return [4 /*yield*/, this._outputSubject.toPromise()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.getCompletion = function () { return __awaiter(_this, void 0, void 0, function () {
+            var messages;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " getCompletion"));
+                        return [4 /*yield*/, this.params.history.toArrayForAgent(this.params.prompt)];
+                    case 1:
+                        messages = _b.sent();
+                        return [4 /*yield*/, this.params.completion.getCompletion({
+                                clientId: this.params.clientId,
+                                agentName: this.params.agentName,
+                                messages: messages,
+                                tools: (_a = this.params.tools) === null || _a === void 0 ? void 0 : _a.map(function (t) { return omit(t, "toolName", "call", "validate"); })
+                            })];
+                    case 2: return [2 /*return*/, _b.sent()];
+                }
+            });
+        }); };
+        this.commitSystemMessage = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " commitSystemMessage"));
+                        return [4 /*yield*/, this.params.history.push({
+                                role: "system",
+                                agentName: this.params.agentName,
+                                content: message.trim(),
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this.commitToolOutput = function (content) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " commitToolOutput content=").concat(content));
+                        return [4 /*yield*/, this.params.history.push({
+                                role: "tool",
+                                agentName: this.params.agentName,
+                                content: content,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._toolCommitSubject.next()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this.execute = queued(function (incoming) { return __awaiter(_this, void 0, void 0, function () {
+            var message, _loop_1, this_1, _a, _b, tool, state_1, e_1_1, result, validation, result1;
+            var e_1, _c;
+            var _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " execute begin"), { incoming: incoming });
+                        return [4 /*yield*/, this.params.history.push({
+                                role: "user",
+                                agentName: this.params.agentName,
+                                content: incoming.trim(),
+                            })];
+                    case 1:
+                        _e.sent();
+                        return [4 /*yield*/, this.getCompletion()];
+                    case 2:
+                        message = _e.sent();
+                        if (!message.tool_calls) return [3 /*break*/, 11];
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " tool call begin"));
+                        _loop_1 = function (tool) {
+                            var targetFn, result_2, result_3;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        targetFn = (_d = this_1.params.tools) === null || _d === void 0 ? void 0 : _d.find(function (t) { return t.function.name === tool.function.name; });
+                                        return [4 /*yield*/, this_1.params.history.push(__assign(__assign({}, message), { agentName: this_1.params.agentName }))];
+                                    case 1:
+                                        _f.sent();
+                                        if (!!targetFn) return [3 /*break*/, 4];
+                                        this_1.params.logger.debug("ClientAgent agentName=".concat(this_1.params.agentName, " functionName=").concat(tool.function.name, " tool function not found"));
+                                        return [4 /*yield*/, this_1._resurrectModel("No target function for ".concat(tool.function.name))];
+                                    case 2:
+                                        result_2 = _f.sent();
+                                        this_1.params.logger.debug("ClientAgent agentName=".concat(this_1.params.agentName, " execute end result=").concat(result_2));
+                                        return [4 /*yield*/, this_1._emitOuput(result_2)];
+                                    case 3:
+                                        _f.sent();
+                                        return [2 /*return*/, { value: void 0 }];
+                                    case 4: return [4 /*yield*/, not(targetFn.validate(this_1.params.clientId, this_1.params.agentName, tool.function.arguments))];
+                                    case 5:
+                                        if (!_f.sent()) return [3 /*break*/, 8];
+                                        this_1.params.logger.debug("ClientAgent agentName=".concat(this_1.params.agentName, " functionName=").concat(tool.function.name, " tool validation not passed"));
+                                        return [4 /*yield*/, this_1._resurrectModel("Function validation failed: name=".concat(tool.function.name, " arguments=").concat(JSON.stringify(tool.function.arguments)))];
+                                    case 6:
+                                        result_3 = _f.sent();
+                                        this_1.params.logger.debug("ClientAgent agentName=".concat(this_1.params.agentName, " execute end result=").concat(result_3));
+                                        return [4 /*yield*/, this_1._emitOuput(result_3)];
+                                    case 7:
+                                        _f.sent();
+                                        return [2 /*return*/, { value: void 0 }];
+                                    case 8:
+                                        /**
+                                         * @description Do not await to avoid deadlock! The tool can send the message to other agents by emulating user messages
+                                         */
+                                        targetFn.call(this_1.params.clientId, this_1.params.agentName, tool.function.arguments);
+                                        this_1.params.logger.debug("ClientAgent agentName=".concat(this_1.params.agentName, " functionName=").concat(tool.function.name, " tool call executing"));
+                                        return [4 /*yield*/, Promise.race([
+                                                this_1._toolCommitSubject.toPromise(),
+                                                this_1._outputSubject.toPromise(),
+                                            ])];
+                                    case 9:
+                                        _f.sent();
+                                        this_1.params.logger.debug("ClientAgent agentName=".concat(this_1.params.agentName, " functionName=").concat(tool.function.name, " tool call end"));
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _e.label = 3;
+                    case 3:
+                        _e.trys.push([3, 8, 9, 10]);
+                        _a = __values(message.tool_calls), _b = _a.next();
+                        _e.label = 4;
+                    case 4:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        tool = _b.value;
+                        return [5 /*yield**/, _loop_1(tool)];
+                    case 5:
+                        state_1 = _e.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        _e.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _e.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                    case 11:
+                        if (!message.tool_calls) {
+                            this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " execute no tool calls detected"));
+                        }
+                        result = message.content;
+                        return [4 /*yield*/, this.params.history.push(__assign(__assign({}, message), { agentName: this.params.agentName }))];
+                    case 12:
+                        _e.sent();
+                        validation = null;
+                        return [4 /*yield*/, this.params.validate(result)];
+                    case 13:
+                        if (!(validation = _e.sent())) return [3 /*break*/, 16];
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " execute invalid tool call detected: ").concat(validation), { result: result });
+                        return [4 /*yield*/, this._resurrectModel("Invalid model output: ".concat(result))];
+                    case 14:
+                        result1 = _e.sent();
+                        return [4 /*yield*/, this._emitOuput(result1)];
+                    case 15:
+                        _e.sent();
+                        return [2 /*return*/];
+                    case 16:
+                        this.params.logger.debug("ClientAgent agentName=".concat(this.params.agentName, " execute end result=").concat(result));
+                        return [4 /*yield*/, this._emitOuput(result)];
+                    case 17:
+                        _e.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    }
+    return ClientAgent;
+}());
+
+var validateNoEmptyResult = function (output) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (!output.trim()) {
+            return [2 /*return*/, "Empty output"];
+        }
+        return [2 /*return*/, null];
+    });
+}); };
+
+var toolParser = new xml2js.Parser();
+var TOOL_CALL_ENTRIES = ["tool_call", "toolcall", "tool"];
+var DISALLOWED_SYMBOLS = [
+    "{",
+    "}",
+];
+/**
+ * @description Validation for not parsed XML toolcall
+ * @see https://github.com/ollama/ollama/issues/8287
+ */
+var validateNoToolCall = trycatch(function (output) { return __awaiter(void 0, void 0, void 0, function () {
+    var DISALLOWED_SYMBOLS_1, DISALLOWED_SYMBOLS_1_1, symbol, result, TOOL_CALL_ENTRIES_1, TOOL_CALL_ENTRIES_1_1, tag;
+    var e_1, _a, e_2, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                try {
+                    for (DISALLOWED_SYMBOLS_1 = __values(DISALLOWED_SYMBOLS), DISALLOWED_SYMBOLS_1_1 = DISALLOWED_SYMBOLS_1.next(); !DISALLOWED_SYMBOLS_1_1.done; DISALLOWED_SYMBOLS_1_1 = DISALLOWED_SYMBOLS_1.next()) {
+                        symbol = DISALLOWED_SYMBOLS_1_1.value;
+                        if (output.includes(symbol)) {
+                            return [2 /*return*/, "Tool call in text output"];
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (DISALLOWED_SYMBOLS_1_1 && !DISALLOWED_SYMBOLS_1_1.done && (_a = DISALLOWED_SYMBOLS_1.return)) _a.call(DISALLOWED_SYMBOLS_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return [4 /*yield*/, toolParser.parseStringPromise(output)];
+            case 1:
+                result = _c.sent();
+                try {
+                    for (TOOL_CALL_ENTRIES_1 = __values(TOOL_CALL_ENTRIES), TOOL_CALL_ENTRIES_1_1 = TOOL_CALL_ENTRIES_1.next(); !TOOL_CALL_ENTRIES_1_1.done; TOOL_CALL_ENTRIES_1_1 = TOOL_CALL_ENTRIES_1.next()) {
+                        tag = TOOL_CALL_ENTRIES_1_1.value;
+                        if (result[tag]) {
+                            return [2 /*return*/, "Tool call in text output"];
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (TOOL_CALL_ENTRIES_1_1 && !TOOL_CALL_ENTRIES_1_1.done && (_b = TOOL_CALL_ENTRIES_1.return)) _b.call(TOOL_CALL_ENTRIES_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return [2 /*return*/, null];
+        }
+    });
+}); }, {
+    defaultValue: null,
+});
+
+var validateDefault = function (output) { return __awaiter(void 0, void 0, void 0, function () {
+    var validation;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                validation = null;
+                return [4 /*yield*/, validateNoEmptyResult(output)];
+            case 1:
+                if (validation = _a.sent()) {
+                    return [2 /*return*/, validation];
+                }
+                return [4 /*yield*/, validateNoToolCall(output)];
+            case 2:
+                if (validation = _a.sent()) {
+                    return [2 /*return*/, validation];
+                }
+                return [2 /*return*/, null];
+        }
+    });
+}); };
+
+var AgentConnectionService = /** @class */ (function () {
+    function AgentConnectionService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.contextService = inject(TYPES.contextService);
+        this.historyConnectionService = inject(TYPES.historyConnectionService);
+        this.agentSchemaService = inject(TYPES.agentSchemaService);
+        this.toolSchemaService = inject(TYPES.toolSchemaService);
+        this.completionSchemaService = inject(TYPES.completionSchemaService);
+        this.getAgent = memoize(function (_a) {
+            var _b = __read(_a, 2), clientId = _b[0], agentName = _b[1];
+            return "".concat(clientId, "-").concat(agentName);
+        }, function (clientId, agentName) {
+            var _a = _this.agentSchemaService.get(agentName), prompt = _a.prompt, tools = _a.tools, completionName = _a.completion, _b = _a.validate, validate = _b === void 0 ? validateDefault : _b;
+            var completion = _this.completionSchemaService.get(completionName);
+            return new ClientAgent({
+                clientId: clientId,
+                agentName: agentName,
+                validate: validate,
+                logger: _this.loggerService,
+                history: _this.historyConnectionService.getHistory(clientId, agentName),
+                prompt: prompt,
+                tools: tools === null || tools === void 0 ? void 0 : tools.map(_this.toolSchemaService.get),
+                completion: completion,
+            });
+        });
+        this.execute = function (input) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentConnectionService execute", {
+                            input: input,
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getAgent(this.contextService.context.clientId, this.contextService.context.agentName).execute(input)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.waitForOutput = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentConnectionService waitForOutput", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getAgent(this.contextService.context.clientId, this.contextService.context.agentName).waitForOutput()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.commitToolOutput = function (content) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentConnectionService commitToolOutput", {
+                            content: content,
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getAgent(this.contextService.context.clientId, this.contextService.context.agentName).commitToolOutput(content)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.commitSystemMessage = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentConnectionService commitSystemMessage", {
+                            message: message,
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getAgent(this.contextService.context.clientId, this.contextService.context.agentName).commitToolOutput(message)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.dispose = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.loggerService.log("agentConnectionService dispose", {
+                    context: this.contextService.context,
+                });
+                this.getAgent.clear("".concat(this.contextService.context.clientId, "-").concat(this.contextService.context.agentName));
+                return [2 /*return*/];
+            });
+        }); };
+    }
+    return AgentConnectionService;
+}());
+
+var ClientHistory = /** @class */ (function () {
+    function ClientHistory(params) {
+        var _this = this;
+        this.params = params;
+        this.push = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("ClientHistory agentName=".concat(this.params.agentName, " push"), { message: message });
+                        return [4 /*yield*/, this.params.items.push(message)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this.toArrayForRaw = function () { return __awaiter(_this, void 0, void 0, function () {
+            var result, _a, _b, _c, item, e_1_1;
+            var _d, e_1, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        this.params.logger.debug("ClientHistory agentName=".concat(this.params.agentName, " toArrayForRaw"));
+                        result = [];
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 6, 7, 12]);
+                        _a = true, _b = __asyncValues(this.params.items);
+                        _g.label = 2;
+                    case 2: return [4 /*yield*/, _b.next()];
+                    case 3:
+                        if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 5];
+                        _f = _c.value;
+                        _a = false;
+                        item = _f;
+                        result.push(item);
+                        _g.label = 4;
+                    case 4:
+                        _a = true;
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 12];
+                    case 6:
+                        e_1_1 = _g.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 12];
+                    case 7:
+                        _g.trys.push([7, , 10, 11]);
+                        if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, _e.call(_b)];
+                    case 8:
+                        _g.sent();
+                        _g.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 11: return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/, result];
+                }
+            });
+        }); };
+        this.toArrayForAgent = function (prompt) { return __awaiter(_this, void 0, void 0, function () {
+            var commonMessagesRaw, systemMessagesRaw, _a, _b, _c, content, message, e_2_1, systemMessages, commonMessages, promptMessage;
+            var _this = this;
+            var _d, e_2, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        this.params.logger.debug("ClientHistory agentName=".concat(this.params.agentName, " toArrayForAgent"));
+                        commonMessagesRaw = [];
+                        systemMessagesRaw = [];
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 6, 7, 12]);
+                        _a = true, _b = __asyncValues(this.params.items);
+                        _g.label = 2;
+                    case 2: return [4 /*yield*/, _b.next()];
+                    case 3:
+                        if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 5];
+                        _f = _c.value;
+                        _a = false;
+                        content = _f;
+                        message = content;
+                        if (message.role === "resque") {
+                            commonMessagesRaw.splice(0, commonMessagesRaw.length);
+                            systemMessagesRaw.splice(0, systemMessagesRaw.length);
+                            return [3 /*break*/, 4];
+                        }
+                        if (message.role === "system") {
+                            systemMessagesRaw.push(message);
+                        }
+                        else {
+                            commonMessagesRaw.push(message);
+                        }
+                        _g.label = 4;
+                    case 4:
+                        _a = true;
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 12];
+                    case 6:
+                        e_2_1 = _g.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 12];
+                    case 7:
+                        _g.trys.push([7, , 10, 11]);
+                        if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, _e.call(_b)];
+                    case 8:
+                        _g.sent();
+                        _g.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (e_2) throw e_2.error;
+                        return [7 /*endfinally*/];
+                    case 11: return [7 /*endfinally*/];
+                    case 12:
+                        systemMessages = systemMessagesRaw.filter(function (_a) {
+                            var agentName = _a.agentName;
+                            return agentName === _this.params.agentName;
+                        });
+                        commonMessages = commonMessagesRaw
+                            .filter(function (_a) {
+                            var role = _a.role, agentName = _a.agentName, tool_calls = _a.tool_calls;
+                            var isOk = true;
+                            if (role === "tool") {
+                                isOk = isOk && agentName === _this.params.agentName;
+                            }
+                            if (tool_calls) {
+                                isOk = isOk && agentName === _this.params.agentName;
+                            }
+                            return isOk;
+                        })
+                            .slice(-GLOBAL_CONFIG.CC_KEEP_MESSAGES);
+                        promptMessage = {
+                            agentName: this.params.agentName,
+                            content: prompt,
+                            role: "system",
+                        };
+                        return [2 /*return*/, __spreadArray(__spreadArray([promptMessage], __read(systemMessages), false), __read(commonMessages), false)];
+                }
+            });
+        }); };
+    }
+    return ClientHistory;
+}());
+
+var HistoryConnectionService = /** @class */ (function () {
+    function HistoryConnectionService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.contextService = inject(TYPES.contextService);
+        this.getItems = memoize(function (_a) {
+            var _b = __read(_a, 1), clientId = _b[0];
+            return clientId;
+        }, function () { return new PubsubArrayAdapter(); });
+        this.getHistory = memoize(function (_a) {
+            var _b = __read(_a, 2), clientId = _b[0], agentName = _b[1];
+            return "".concat(clientId, "-").concat(agentName);
+        }, function (clientId, agentName) {
+            return new ClientHistory({
+                clientId: clientId,
+                agentName: agentName,
+                items: _this.getItems(clientId),
+                logger: _this.loggerService,
+            });
+        });
+        this.push = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("historyConnectionService push", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getHistory(this.contextService.context.clientId, this.contextService.context.agentName).push(message)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.toArrayForAgent = function (prompt) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("historyConnectionService toArrayForAgent", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getHistory(this.contextService.context.clientId, this.contextService.context.agentName).toArrayForAgent(prompt)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.toArrayForRaw = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("historyConnectionService toArrayForRaw", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getHistory(this.contextService.context.clientId, this.contextService.context.agentName).toArrayForRaw()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.dispose = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("historyConnectionService dispose", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getItems(this.contextService.context.clientId).clear()];
+                    case 1:
+                        _a.sent();
+                        this.getItems.clear(this.contextService.context.clientId);
+                        this.getHistory.clear("".concat(this.contextService.context.clientId, "-").concat(this.contextService.context.agentName));
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+    }
+    return HistoryConnectionService;
+}());
+
+var ToolSchemaService = /** @class */ (function () {
+    function ToolSchemaService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.registry = new ToolRegistry("toolSchemaService");
+        this.register = function (key, value) {
+            _this.loggerService.log('toolSchemaService register');
+            _this.registry = _this.registry.register(key, value);
+        };
+        this.get = function (key) {
+            _this.loggerService.log('toolSchemaService get', { key: key });
+            return _this.registry.get(key);
+        };
+    }
+    return ToolSchemaService;
+}());
+
+var ClientSwarm = /** @class */ (function () {
+    function ClientSwarm(params) {
+        var _this = this;
+        this.params = params;
+        this.waitForOutput = function () { return __awaiter(_this, void 0, void 0, function () {
+            var START_TIME, _a, agentName, output, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.params.logger.debug("BaseConnection waitForOutput");
+                        START_TIME = Date.now();
+                        _c.label = 1;
+                    case 1:
+                        if (Date.now() - START_TIME >= GLOBAL_CONFIG.CC_ANSWER_TIMEOUT_SECONDS) {
+                            throw new Error("agent-swarm ClientSwarm waitForOutput timeout reached for ".concat(this.params.swarmName));
+                        }
+                        return [4 /*yield*/, Promise.race(Object.entries(this.params.agentMap).map(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                                var _c;
+                                var _d = __read(_b, 2), agentName = _d[0], agent = _d[1];
+                                return __generator(this, function (_e) {
+                                    switch (_e.label) {
+                                        case 0:
+                                            _c = [agentName];
+                                            return [4 /*yield*/, agent.waitForOutput()];
+                                        case 1: return [2 /*return*/, _c.concat([
+                                                _e.sent()
+                                            ])];
+                                    }
+                                });
+                            }); }))];
+                    case 2:
+                        _a = __read.apply(void 0, [_c.sent(), 2]), agentName = _a[0], output = _a[1];
+                        _b = agentName;
+                        return [4 /*yield*/, this.getAgentName()];
+                    case 3:
+                        if (_b === (_c.sent())) {
+                            return [2 /*return*/, output];
+                        }
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); };
+        this.getAgentName = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.params.logger.debug("ClientSwarm getAgentName");
+                return [2 /*return*/, this._activeAgent];
+            });
+        }); };
+        this.getAgent = function () { return __awaiter(_this, void 0, void 0, function () {
+            var agent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("ClientSwarm getAgent");
+                        return [4 /*yield*/, this.getAgentName()];
+                    case 1:
+                        agent = _a.sent();
+                        return [2 /*return*/, this.params.agentMap[agent]];
+                }
+            });
+        }); };
+        this.setAgentName = function (agentName) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.params.logger.debug("ClientSwarm setAgentName agentName=".concat(agentName));
+                this._activeAgent = agentName;
+                return [2 /*return*/];
+            });
+        }); };
+        this._activeAgent = params.defaultAgent;
+    }
+    return ClientSwarm;
+}());
+
+var SwarmConnectionService = /** @class */ (function () {
+    function SwarmConnectionService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.contextService = inject(TYPES.contextService);
+        this.agentConnectionService = inject(TYPES.agentConnectionService);
+        this.swarmSchemaService = inject(TYPES.swarmSchemaService);
+        this.getSwarm = memoize(function (_a) {
+            var _b = __read(_a, 2), clientId = _b[0], swarmName = _b[1];
+            return "".concat(clientId, "-").concat(swarmName);
+        }, function (clientId, swarmName) {
+            var e_1, _a;
+            var _b = _this.swarmSchemaService.get(swarmName), agentList = _b.agentList, defaultAgent = _b.defaultAgent;
+            var agentMap = {};
+            try {
+                for (var agentList_1 = __values(agentList), agentList_1_1 = agentList_1.next(); !agentList_1_1.done; agentList_1_1 = agentList_1.next()) {
+                    var agentName = agentList_1_1.value;
+                    agentMap[agentName] = _this.agentConnectionService.getAgent(clientId, agentName);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (agentList_1_1 && !agentList_1_1.done && (_a = agentList_1.return)) _a.call(agentList_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return new ClientSwarm({
+                clientId: clientId,
+                agentMap: agentMap,
+                defaultAgent: defaultAgent,
+                swarmName: swarmName,
+                logger: _this.loggerService,
+            });
+        });
+        this.waitForOutput = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmConnectionService waitForOutput", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getSwarm(this.contextService.context.clientId, this.contextService.context.swarmName).waitForOutput()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.getAgentName = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmConnectionService getAgentName", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getSwarm(this.contextService.context.clientId, this.contextService.context.swarmName).getAgentName()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.getAgent = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmConnectionService getAgent", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getSwarm(this.contextService.context.clientId, this.contextService.context.swarmName).getAgent()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.setAgentName = function (agentName) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmConnectionService setAgentName", {
+                            agentName: agentName,
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getSwarm(this.contextService.context.clientId, this.contextService.context.swarmName).setAgentName(agentName)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.dispose = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.loggerService.log("swarmConnectionService dispose", {
+                    context: this.contextService.context,
+                });
+                this.getSwarm.clear("".concat(this.contextService.context.clientId, "-").concat(this.contextService.context.swarmName));
+                return [2 /*return*/];
+            });
+        }); };
+    }
+    return SwarmConnectionService;
+}());
+
+var SwarmSchemaService = /** @class */ (function () {
+    function SwarmSchemaService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.registry = new ToolRegistry("swarmSchemaService");
+        this.register = function (key, value) {
+            _this.loggerService.log("swarmSchemaService register", { key: key });
+            _this.registry = _this.registry.register(key, value);
+        };
+        this.get = function (key) {
+            _this.loggerService.log("swarmSchemaService get", { key: key });
+            return _this.registry.get(key);
+        };
+    }
+    return SwarmSchemaService;
+}());
+
+var CompletionSchemaService = /** @class */ (function () {
+    function CompletionSchemaService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.registry = new ToolRegistry("completionSchemaService");
+        this.register = function (key, value) {
+            _this.loggerService.log("completionSchemaService register", { key: key });
+            _this.registry = _this.registry.register(key, value);
+        };
+        this.get = function (key) {
+            _this.loggerService.log("completionSchemaService get", { key: key });
+            return _this.registry.get(key);
+        };
+    }
+    return CompletionSchemaService;
+}());
+
+var ClientSession = /** @class */ (function () {
+    function ClientSession(params) {
+        var _this = this;
+        this.params = params;
+        this.execute = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            var agent, output;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("BaseSession execute", {
+                            message: message,
+                        });
+                        return [4 /*yield*/, this.params.swarm.getAgent()];
+                    case 1:
+                        agent = _a.sent();
+                        output = this.params.swarm.waitForOutput();
+                        agent.execute(message);
+                        return [4 /*yield*/, output];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.commitToolOutput = function (content) { return __awaiter(_this, void 0, void 0, function () {
+            var agent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("BaseSession commitToolOutput", {
+                            content: content,
+                        });
+                        return [4 /*yield*/, this.params.swarm.getAgent()];
+                    case 1:
+                        agent = _a.sent();
+                        return [4 /*yield*/, agent.commitToolOutput(content)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.commitSystemMessage = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            var agent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.params.logger.debug("BaseSession commitSystemMessage", {
+                            message: message,
+                        });
+                        return [4 /*yield*/, this.params.swarm.getAgent()];
+                    case 1:
+                        agent = _a.sent();
+                        return [4 /*yield*/, agent.commitSystemMessage(message)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.connect = function (connector) {
+            _this.params.logger.debug("BaseSession connect");
+            return function (incoming) { return __awaiter(_this, void 0, void 0, function () {
+                var _a;
+                var _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            this.params.logger.debug("BaseSession connect call");
+                            _a = connector;
+                            _b = {};
+                            return [4 /*yield*/, this.execute(incoming.data)];
+                        case 1:
+                            _b.data = _c.sent();
+                            return [4 /*yield*/, this.params.swarm.getAgentName()];
+                        case 2: return [4 /*yield*/, _a.apply(void 0, [(_b.agentName = _c.sent(),
+                                    _b.clientId = incoming.clientId,
+                                    _b)])];
+                        case 3:
+                            _c.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); };
+        };
+    }
+    return ClientSession;
+}());
+
+var SessionConnectionService = /** @class */ (function () {
+    function SessionConnectionService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.contextService = inject(TYPES.contextService);
+        this.swarmConnectionService = inject(TYPES.swarmConnectionService);
+        this.getSession = memoize(function (_a) {
+            var _b = __read(_a, 2), clientId = _b[0], swarmName = _b[1];
+            return "".concat(clientId, "-").concat(swarmName);
+        }, function (clientId, swarmName) {
+            return new ClientSession({
+                clientId: clientId,
+                logger: _this.loggerService,
+                swarm: _this.swarmConnectionService.getSwarm(clientId, swarmName),
+            });
+        });
+        this.execute = function (content) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("sessionConnectionService execute", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getSession(this.contextService.context.clientId, this.contextService.context.swarmName).execute(content)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.connect = function (connector) {
+            _this.loggerService.log("sessionConnectionService connect", {
+                context: _this.contextService.context,
+            });
+            return _this.getSession(_this.contextService.context.clientId, _this.contextService.context.swarmName).connect(connector);
+        };
+        this.commitToolOutput = function (content) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("sessionConnectionService commitToolOutput", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getSession(this.contextService.context.clientId, this.contextService.context.swarmName).commitToolOutput(content)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.commitSystemMessage = function (message) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("sessionConnectionService commitSystemMessage", {
+                            context: this.contextService.context,
+                        });
+                        return [4 /*yield*/, this.getSession(this.contextService.context.clientId, this.contextService.context.swarmName).commitSystemMessage(message)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.dispose = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.loggerService.log("sessionConnectionService dispose", {
+                    context: this.contextService.context,
+                });
+                this.getSession.clear("".concat(this.contextService.context.clientId, "-").concat(this.contextService.context.swarmName));
+                return [2 /*return*/];
+            });
+        }); };
+    }
+    return SessionConnectionService;
+}());
+
+var AgentPublicService = /** @class */ (function () {
+    function AgentPublicService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.agentConnectionService = inject(TYPES.agentConnectionService);
+        this.execute = function (input, clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentPublicService execute", {
+                            input: input,
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.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.execute(input)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.waitForOutput = function (clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentPublicService waitForOutput", {
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.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.waitForOutput()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.commitToolOutput = function (content, clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentPublicService commitToolOutput", {
+                            content: content,
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.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.commitToolOutput(content)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.commitSystemMessage = function (message, clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentPublicService commitSystemMessage", {
+                            message: message,
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.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.commitSystemMessage(message)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.dispose = function (clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("agentPublicService dispose", {
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.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.dispose()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return AgentPublicService;
+}());
+
+var HistoryPublicService = /** @class */ (function () {
+    function HistoryPublicService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.historyConnectionService = inject(TYPES.historyConnectionService);
+        this.push = function (message, clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("historyPublicService push", {
+                            message: message,
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.historyConnectionService.push(message)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.toArrayForAgent = function (prompt, clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("historyPublicService toArrayForAgent", {
+                            prompt: prompt,
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.historyConnectionService.toArrayForAgent(prompt)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.toArrayForRaw = function (clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("historyPublicService toArrayForRaw", {
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.historyConnectionService.toArrayForRaw()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.dispose = function (clientId, agentName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("historyPublicService dispose", {
+                            clientId: clientId,
+                            agentName: agentName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.historyConnectionService.dispose()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                agentName: agentName,
+                                swarmName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return HistoryPublicService;
+}());
+
+var SessionPublicService = /** @class */ (function () {
+    function SessionPublicService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.sessionConnectionService = inject(TYPES.sessionConnectionService);
+        this.execute = function (content, clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("sessionPublicService execute", {
+                            content: content,
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.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.execute(content)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.connect = function (connector, clientId, swarmName) {
+            _this.loggerService.log("sessionPublicService connect", {
+                clientId: clientId,
+                swarmName: swarmName,
+            });
+            return ContextService.runInContext(function () {
+                var receive = _this.sessionConnectionService.connect(function (outgoing) { return __awaiter(_this, void 0, void 0, function () {
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4 /*yield*/, connector(outgoing)];
+                                            case 1: return [2 /*return*/, _a.sent()];
+                                        }
+                                    });
+                                }); }, {
+                                    clientId: clientId,
+                                    swarmName: swarmName,
+                                    agentName: "",
+                                })];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    });
+                }); });
+                return function (incoming) {
+                    return ContextService.runInContext(function () {
+                        return receive(incoming);
+                    }, {
+                        clientId: clientId,
+                        swarmName: swarmName,
+                        agentName: "",
+                    });
+                };
+            }, {
+                clientId: clientId,
+                swarmName: swarmName,
+                agentName: "",
+            });
+        };
+        this.commitToolOutput = function (content, clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("sessionPublicService commitToolOutput", {
+                            content: content,
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.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.commitToolOutput(content)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.commitSystemMessage = function (message, clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("sessionPublicService commitSystemMessage", {
+                            message: message,
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.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.commitSystemMessage(message)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.dispose = function (clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("sessionPublicService dispose", {
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.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.dispose()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return SessionPublicService;
+}());
+
+var SwarmPublicService = /** @class */ (function () {
+    function SwarmPublicService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.swarmConnectionService = inject(TYPES.swarmConnectionService);
+        this.waitForOutput = function (clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmPublicService waitForOutput", {
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.swarmConnectionService.waitForOutput()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.getAgentName = function (clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmPublicService getAgentName", {
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.swarmConnectionService.getAgentName()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.getAgent = function (clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmPublicService getAgent", {
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.swarmConnectionService.getAgent()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.setAgentName = function (agentName, clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmPublicService setAgentName", {
+                            agentName: agentName,
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.swarmConnectionService.setAgentName(agentName)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.dispose = function (clientId, swarmName) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loggerService.log("swarmPublicService dispose", {
+                            clientId: clientId,
+                            swarmName: swarmName,
+                        });
+                        return [4 /*yield*/, ContextService.runInContext(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.swarmConnectionService.dispose()];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); }, {
+                                clientId: clientId,
+                                swarmName: swarmName,
+                                agentName: "",
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+    }
+    return SwarmPublicService;
+}());
+
+var AgentValidationService = /** @class */ (function () {
+    function AgentValidationService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.toolValidationService = inject(TYPES.toolValidationService);
+        this.completionValidationService = inject(TYPES.completionValidationService);
+        this._agentMap = new Map();
+        this.addAgent = function (agentName, agentSchema) {
+            _this.loggerService.log("agentValidationService addAgent", {
+                agentName: agentName,
+                agentSchema: agentSchema,
+            });
+            if (_this._agentMap.has(agentName)) {
+                throw new Error("agent-swarm agent ".concat(agentName, " already exist"));
+            }
+            _this._agentMap.set(agentName, agentSchema);
+        };
+        this.validate = memoize(function (_a) {
+            var _b = __read(_a, 1), agentName = _b[0];
+            return agentName;
+        }, function (agentName, source) {
+            var _a;
+            _this.loggerService.log("agentValidationService validate", {
+                agentName: agentName,
+                source: source,
+            });
+            var agent = _this._agentMap.get(agentName);
+            if (!agent) {
+                throw new Error("agent-swarm agent ".concat(agentName, " not found source=").concat(source));
+            }
+            _this.completionValidationService.validate(agent.completion, source);
+            (_a = agent.tools) === null || _a === void 0 ? void 0 : _a.forEach(function (toolName) {
+                _this.toolValidationService.validate(toolName, source);
+            });
+        });
+    }
+    return AgentValidationService;
+}());
+
+var CompletionValidationService = /** @class */ (function () {
+    function CompletionValidationService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this._completionSet = new Set();
+        this.addCompletion = function (completionName) {
+            _this.loggerService.log("completionValidationService addCompletion", {
+                completionName: completionName,
+            });
+            if (_this._completionSet.has(completionName)) {
+                throw new Error("agent-swarm completion ".concat(completionName, " already exist"));
+            }
+            _this._completionSet.add(completionName);
+        };
+        this.validate = memoize(function (_a) {
+            var _b = __read(_a, 1), completionName = _b[0];
+            return completionName;
+        }, function (completionName, source) {
+            _this.loggerService.log("completionValidationService validate", {
+                completionName: completionName,
+                source: source,
+            });
+            if (!_this._completionSet.has(completionName)) {
+                throw new Error("agent-swarm completion ".concat(completionName, " not found source=").concat(source));
+            }
+        });
+    }
+    return CompletionValidationService;
+}());
+
+var SessionValidationService = /** @class */ (function () {
+    function SessionValidationService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this._sessionMap = new Map();
+        this.addSession = function (clientId, swarmName) {
+            _this.loggerService.log("sessionValidationService addSession", {
+                clientId: clientId,
+            });
+            if (_this._sessionMap.has(clientId)) {
+                throw new Error("agent-swarm session clientId=".concat(clientId, " already exist"));
+            }
+            _this._sessionMap.set(clientId, swarmName);
+        };
+        this.getSessionList = function () {
+            _this.loggerService.log("sessionValidationService getSessionList");
+            return __spreadArray([], __read(_this._sessionMap.keys()), false);
+        };
+        this.getSwarm = function (clientId) {
+            _this.loggerService.log("sessionValidationService getSwarm", {
+                clientId: clientId,
+            });
+            var session = _this._sessionMap.get(clientId);
+            if (session === undefined) {
+                throw new Error("agent-swarm session clientId=".concat(clientId, " not found"));
+            }
+            return session;
+        };
+        this.validate = function (clientId, source) {
+            _this.loggerService.log("sessionValidationService validate", { clientId: clientId });
+            if (!_this._sessionMap.has(clientId)) {
+                throw new Error("agent-swarm session clientId=".concat(clientId, " not exist source=").concat(source));
+            }
+        };
+        this.removeSession = function (clientId) {
+            _this.loggerService.log("sessionValidationService addSession", {
+                clientId: clientId,
+            });
+            _this._sessionMap.delete(clientId);
+        };
+    }
+    return SessionValidationService;
+}());
+
+var SwarmValidationService = /** @class */ (function () {
+    function SwarmValidationService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this.agentValidationService = inject(TYPES.agentValidationService);
+        this._swarmMap = new Map();
+        this.addSwarm = function (swarmName, swarmSchema) {
+            _this.loggerService.log("swarmValidationService addSwarm", {
+                swarmName: swarmName,
+                swarmSchema: swarmSchema,
+            });
+            if (_this._swarmMap.has(swarmName)) {
+                throw new Error("swarm-swarm swarm ".concat(swarmName, " already exist"));
+            }
+            _this._swarmMap.set(swarmName, swarmSchema);
+        };
+        this.getAgentList = function (swarmName) {
+            _this.loggerService.log("swarmValidationService getAgentList", {
+                swarmName: swarmName,
+            });
+            var swarm = _this._swarmMap.get(swarmName);
+            if (!swarm) {
+                throw new Error("agent-swarm swarm ".concat(swarmName, " not found"));
+            }
+            return swarm.agentList;
+        };
+        this.validate = memoize(function (_a) {
+            var _b = __read(_a, 1), swarmName = _b[0];
+            return swarmName;
+        }, function (swarmName, source) {
+            _this.loggerService.log("swarmValidationService validate", {
+                swarmName: swarmName,
+                source: source,
+            });
+            var swarm = _this._swarmMap.get(swarmName);
+            if (!swarm) {
+                throw new Error("agent-swarm swarm ".concat(swarmName, " not found"));
+            }
+            if (!swarm.agentList.includes(swarm.defaultAgent)) {
+                throw new Error("agent-swarm swarm ".concat(swarmName, " default agent not in agent list"));
+            }
+            swarm.agentList.forEach(function (agentName) {
+                return _this.agentValidationService.validate(agentName, source);
+            });
+        });
+    }
+    return SwarmValidationService;
+}());
+
+var ToolValidationService = /** @class */ (function () {
+    function ToolValidationService() {
+        var _this = this;
+        this.loggerService = inject(TYPES.loggerService);
+        this._toolMap = new Map();
+        this.addTool = function (toolName, toolSchema) {
+            _this.loggerService.log("toolValidationService addTool", {
+                toolName: toolName,
+                toolSchema: toolSchema,
+            });
+            if (_this._toolMap.has(toolName)) {
+                throw new Error("agent-swarm tool ".concat(toolName, " already exist"));
+            }
+            _this._toolMap.set(toolName, toolSchema);
+        };
+        this.validate = memoize(function (_a) {
+            var _b = __read(_a, 1), toolName = _b[0];
+            return toolName;
+        }, function (toolName, source) {
+            _this.loggerService.log("toolValidationService validate", {
+                toolName: toolName,
+                source: source,
+            });
+            if (!_this._toolMap.has(toolName)) {
+                throw new Error("agent-swarm tool ".concat(toolName, " not found source=").concat(source));
+            }
+        });
+    }
+    return ToolValidationService;
+}());
+
+{
+    provide(TYPES.loggerService, function () { return new LoggerService(); });
+    provide(TYPES.contextService, function () { return new ContextService(); });
+}
+{
+    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.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.agentPublicService, function () { return new AgentPublicService(); });
+    provide(TYPES.historyPublicService, function () { return new HistoryPublicService(); });
+    provide(TYPES.sessionPublicService, function () { return new SessionPublicService(); });
+    provide(TYPES.swarmPublicService, function () { return new SwarmPublicService(); });
+}
+{
+    provide(TYPES.agentPublicService, function () { return new AgentPublicService(); });
+    provide(TYPES.historyPublicService, function () { return new HistoryPublicService(); });
+    provide(TYPES.sessionPublicService, function () { return new SessionPublicService(); });
+    provide(TYPES.swarmPublicService, function () { return new SwarmPublicService(); });
+}
+{
+    provide(TYPES.agentValidationService, function () { return new AgentValidationService(); });
+    provide(TYPES.completionValidationService, function () { return new CompletionValidationService(); });
+    provide(TYPES.sessionValidationService, function () { return new SessionValidationService(); });
+    provide(TYPES.swarmValidationService, function () { return new SwarmValidationService(); });
+    provide(TYPES.toolValidationService, function () { return new ToolValidationService(); });
+}
+
+var baseServices = {
+    loggerService: inject(TYPES.loggerService),
+    contextService: inject(TYPES.contextService),
+};
+var connectionServices = {
+    agentConnectionService: inject(TYPES.agentConnectionService),
+    historyConnectionService: inject(TYPES.historyConnectionService),
+    swarmConnectionService: inject(TYPES.swarmConnectionService),
+    sessionConnectionService: inject(TYPES.sessionConnectionService),
+};
+var specServices = {
+    agentSchemaService: inject(TYPES.agentSchemaService),
+    toolSchemaService: inject(TYPES.toolSchemaService),
+    swarmSchemaService: inject(TYPES.swarmSchemaService),
+    completionSchemaService: inject(TYPES.completionSchemaService),
+};
+var publicServices = {
+    agentPublicService: inject(TYPES.agentPublicService),
+    historyPublicService: inject(TYPES.historyPublicService),
+    sessionPublicService: inject(TYPES.sessionPublicService),
+    swarmPublicService: inject(TYPES.swarmPublicService),
+};
+var validationServices = {
+    agentValidationService: inject(TYPES.agentValidationService),
+    toolValidationService: inject(TYPES.toolValidationService),
+    sessionValidationService: inject(TYPES.sessionValidationService),
+    swarmValidationService: inject(TYPES.swarmValidationService),
+    completionValidationService: inject(TYPES.completionValidationService),
+};
+var swarm = __assign(__assign(__assign(__assign(__assign({}, baseServices), connectionServices), specServices), publicServices), validationServices);
+init();
+
+var addAgent = function (agentSchema) {
+    swarm.agentValidationService.addAgent(agentSchema.agentName, agentSchema);
+    swarm.agentSchemaService.register(agentSchema.agentName, agentSchema);
+    return agentSchema.agentName;
+};
+
+var addCompletion = function (completionSchema) {
+    swarm.completionValidationService.addCompletion(completionSchema.completionName);
+    swarm.completionSchemaService.register(completionSchema.completionName, completionSchema);
+    return completionSchema.completionName;
+};
+
+var addSwarm = function (swarmSchema) {
+    swarm.swarmValidationService.addSwarm(swarmSchema.swarmName, swarmSchema);
+    swarm.swarmSchemaService.register(swarmSchema.swarmName, swarmSchema);
+    return swarmSchema.swarmName;
+};
+
+var addTool = function (toolSchema) {
+    swarm.toolValidationService.addTool(toolSchema.toolName, toolSchema);
+    swarm.toolSchemaService.register(toolSchema.toolName, toolSchema);
+    return toolSchema.toolName;
+};
+
+var makeConnection = function (connector, clientId, swarmName) {
+    swarm.swarmValidationService.validate(swarmName, "makeConnection");
+    swarm.sessionValidationService.addSession(clientId, swarmName);
+    var send = swarm.sessionPublicService.connect(connector, clientId, swarmName);
+    return queued(function (outgoing) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    swarm.sessionValidationService.validate(clientId, "makeConnection");
+                    return [4 /*yield*/, send(outgoing)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); });
+};
+
+var changeAgent = function (agentName, clientId) { return __awaiter(void 0, void 0, void 0, function () {
+    var swarmName;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                swarm.sessionValidationService.validate(clientId, "changeAgent");
+                swarm.agentValidationService.validate(agentName, "changeAgent");
+                swarmName = swarm.sessionValidationService.getSwarm(clientId);
+                return [4 /*yield*/, swarm.swarmPublicService.setAgentName(agentName, clientId, swarmName)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+
+var disposeConnection = function (clientId, swarmName) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                swarm.swarmValidationService.validate(swarmName, "disposeConnection");
+                swarm.sessionValidationService.removeSession(clientId);
+                return [4 /*yield*/, swarm.sessionPublicService.dispose(clientId, swarmName)];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, swarm.swarmPublicService.dispose(clientId, swarmName)];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, Promise.all([
+                        swarm.swarmValidationService
+                            .getAgentList(swarmName)
+                            .map(function (agentName) { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, swarm.agentPublicService.dispose(clientId, agentName)];
+                                    case 1:
+                                        _a.sent();
+                                        return [4 /*yield*/, swarm.historyPublicService.dispose(clientId, agentName)];
+                                    case 2:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }),
+                    ])];
+            case 3:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+
+var COMPLETE_TTL = 15 * 60 * 1000;
+var COMPLETE_GC = 60 * 1000;
+var createComplete = ttl(function (clientId, swarmName) {
+    return queued(function (content) { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    swarm.swarmValidationService.validate(swarmName, "complete");
+                    swarm.sessionValidationService.addSession(clientId, swarmName);
+                    return [4 /*yield*/, swarm.sessionPublicService.execute(content, clientId, swarmName)];
+                case 1:
+                    result = _a.sent();
+                    return [4 /*yield*/, disposeConnection(clientId, swarmName)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, result];
+            }
+        });
+    }); });
+}, {
+    key: function (_a) {
+        var _b = __read(_a, 2), clientId = _b[0], swarmName = _b[1];
+        return "".concat(clientId, "-").concat(swarmName);
+    },
+    timeout: COMPLETE_TTL,
+});
+var createGc = singleshot(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        setInterval(createComplete.gc, COMPLETE_GC);
+        return [2 /*return*/];
+    });
+}); });
+var complete = function (content, clientId, swarmName) { return __awaiter(void 0, void 0, void 0, function () {
+    var run;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, createComplete(clientId, swarmName)];
+            case 1:
+                run = _a.sent();
+                createGc();
+                return [4 /*yield*/, run(content)];
+            case 2: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+
+var session = function (clientId, swarmName) {
+    swarm.swarmValidationService.validate(swarmName, "session");
+    swarm.sessionValidationService.addSession(clientId, swarmName);
+    return {
+        complete: queued(function (content) { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        swarm.sessionValidationService.validate(clientId, "session");
+                        return [4 /*yield*/, swarm.sessionPublicService.execute(content, clientId, swarmName)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); }),
+        dispose: function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, disposeConnection(clientId, swarmName)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); },
+    };
+};
+
+var getRawHistory = function (clientId) { return __awaiter(void 0, void 0, void 0, function () {
+    var swarmName, agentName, history;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                swarm.sessionValidationService.validate(clientId, "getRawHistory");
+                swarmName = swarm.sessionValidationService.getSwarm(clientId);
+                swarm.swarmValidationService.validate(swarmName, "getRawHistory");
+                return [4 /*yield*/, swarm.swarmPublicService.getAgentName(clientId, swarmName)];
+            case 1:
+                agentName = _a.sent();
+                return [4 /*yield*/, swarm.historyPublicService.toArrayForRaw(clientId, agentName)];
+            case 2:
+                history = _a.sent();
+                return [2 /*return*/, __spreadArray([], __read(history), false)];
+        }
+    });
+}); };
+
+var getAgentHistory = function (clientId, agentName) { return __awaiter(void 0, void 0, void 0, function () {
+    var prompt, history;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                swarm.agentValidationService.validate(agentName, "getAgentHistory");
+                prompt = swarm.agentSchemaService.get(agentName).prompt;
+                return [4 /*yield*/, swarm.historyPublicService.toArrayForAgent(prompt, clientId, agentName)];
+            case 1:
+                history = _a.sent();
+                return [2 /*return*/, __spreadArray([], __read(history), false)];
+        }
+    });
+}); };
+
+var commitToolOutput = function (content, clientId) {
+    swarm.sessionValidationService.validate(clientId, "commitToolOutput");
+    var swarmName = swarm.sessionValidationService.getSwarm(clientId);
+    swarm.swarmValidationService.validate(swarmName, "commitToolOutput");
+    swarm.sessionPublicService.commitToolOutput(content, clientId, swarmName);
+};
+
+var commitSystemMessage = function (content, clientId) {
+    swarm.sessionValidationService.validate(clientId, "commitSystemMessage");
+    var swarmName = swarm.sessionValidationService.getSwarm(clientId);
+    swarm.swarmValidationService.validate(swarmName, "commitSystemMessage");
+    swarm.sessionPublicService.commitSystemMessage(content, clientId, swarmName);
+};
+
+var execute = function (content, clientId) { return __awaiter(void 0, void 0, void 0, function () {
+    var swarmName;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                swarm.sessionValidationService.validate(clientId, "execute");
+                swarmName = swarm.sessionValidationService.getSwarm(clientId);
+                swarm.swarmValidationService.validate(swarmName, "execute");
+                return [4 /*yield*/, swarm.sessionPublicService.execute(content, clientId, swarmName)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+
+export { ContextService, addAgent, addCompletion, addSwarm, addTool, changeAgent, commitSystemMessage, commitToolOutput, complete, disposeConnection, execute, getAgentHistory, getRawHistory, makeConnection, session, setConfig, swarm };